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

Annotations already declare this is a non-readonly, non-idempotent, non-destructive, open-world write, so the safety profile is covered. The description adds only a vague 'sandbox first if no host' note and 'repo_url (already live)' remark that belong to a different tool, giving no real behavioral context for a template deployment.

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 text is short and free of padding, so nothing is wasted, but it is not front-loaded on the actual purpose and the cryptic sequencing (arrows, abbreviations) hinders comprehension rather than aiding it.

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 non-idempotent deployment tool with a required undocumented parameter, no output schema and 0% schema coverage, the description should explain what a template is, what gets created, and what happens on failure. It does none of this and instead describes an unrelated app-deploy flow.

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 0% and the single required 'template' parameter is never described; instead the description references non-existent parameters (local_dir, repo_url). The title 'MONA Agent template' weakly implies template is a template identifier, but behavior around it is unaddressed.

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 it 'calls the same runtime as cloud_agent_deploy' and then describes deploying an app directory or git repo (cloud_app_detect → cloud_app_create(local_dir), repo_url). That flow does not match this tool's actual single 'template' parameter, so the stated purpose looks pasted from a different deploy tool and never clearly says what agent_deploy does with a template.

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 hints at a relationship with the sibling cloud_agent_deploy ('same runtime') and says to use sandbox first if there is no host, but it never says when to pick agent_deploy over agent_templates_get/list or cloud_agent_deploy, nor what prerequisites (auth, existing host) are required.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description usefully adds that the response spans multiple named artifacts (README, deploy, checklist, skills), but says nothing about the openWorld implication or the shape/size of the returned payload.

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 with no filler, and the enumerated artifacts are the most useful content it could carry. Efficient, if minimal.

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 and only one parameter, the description covers the minimum: what is read and from where. It leaves the return structure (how the multiple artifacts are keyed) and the slug semantics unaddressed.

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?

One required parameter with 0% schema description coverage and no enum. The description never explains that 'template' is a slug matching ^[a-z0-9][a-z0-9-]{0,79}$ (lowercase, hyphenated, max 80 chars), so an agent has no guidance on accepted values beyond the bare pattern.

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 concrete verb ('Đọc') and a specific resource set: README, AGENTS.md, tools, deploy, checklist, skills of one template. This is clearly a detail-fetch counterpart to agent_templates_list, though the description never names that sibling to make the distinction explicit.

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

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

No indication of when to use this versus agent_templates_list, no prerequisites, no mention of what happens with an invalid slug. The agent must infer the usage context entirely.

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, openWorldHint=true, and destructiveHint=false. The description is consistent with those, adding that templates can be read from local storage, a catalog URL, or an integrated wave 1 catalog. It does not add much beyond the annotations and does not describe return format or source-selection 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 core purpose is front-loaded in the first sentence, but the second sentence is an unrelated deployment workflow that does not help an agent call agent_templates_list correctly. It is short, but not 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 no-parameter, read-only tool with annotations covering safety and no output schema, the description is minimally adequate. However, mixing in deployment steps makes the tool's role relative to agent_templates_get, agent_deploy, and cloud_app_create less clear, leaving ambiguity about when this catalog list is the right choice.

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

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

The tool has zero parameters, so the baseline for parameter semantics is 4. The description mentions three template sources but does not document any input fields, which is acceptable because the schema contains no parameters to explain.

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 first sentence states a specific verb and resource: 'Đọc template' from local directory, catalog URL, or integrated wave 1 catalog. However, it does not distinguish this tool from the sibling agent_templates_get, and the second sentence about deploying a project via cloud_app_detect and cloud_app_create muddles what agent_templates_list itself does.

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 names source locations but does not say when to choose this tool over agent_templates_get or other siblings. The only workflow guidance is for deployment ('Deploy dự án: cloud_app_detect rồi cloud_app_create'), which is a different task rather than instruction on using this listing tool.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, covering the safety/mutation profile. The description adds the time-window constraint ('thời hạn cho phép') and scoping to the 'current account', which is useful beyond the annotations, but says nothing about what happens on a duplicate or failed claim.

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 short and the core action is front-loaded, but the Vietnamese and English lines are verbatim duplicates, so the bilingual repetition consumes space without adding distinct 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?

For a mutation tool with no output schema and a 0%-documented parameter, the description is thin. It does not explain the effect of claiming, what happens on an invalid/expired code, or any post-claim state, leaving an agent without enough to predict outcomes.

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

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

Schema description coverage is 0% and the description does not compensate. It implies the single parameter is a referral code ('mã giới thiệu'), but omits the length bounds (4–16 chars), format, or validation behavior that the schema leaves undocumented.

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

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

States a specific verb and resource ('Claim a referral code for the current account'), so the action is clear. It does not, however, explicitly distinguish itself from siblings like cloud_affiliate_link or vibecloud_affiliate_claim, so the differentiation is only implicit.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. The phrase 'trong thời hạn cho phép' (within the allowed period) hints at a timing constraint but is not an explicit usage rule.

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=false, so safety is covered and the description is consistent with them. The description adds that the payload includes revenue-share rates alongside the link, but says nothing about account/auth requirements or whether the referral code is user-specific.

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 (bilingual duplication) with the action and payload front-loaded and no filler. The mirrored Vietnamese/English text is redundant for an agent but adds no ambiguity or bloat.

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

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

For a zero-parameter, read-only tool the description is nearly sufficient: it names the returned artifacts (referral link, revenue-share rates), which compensates for the absent output schema. It could still note that it only retrieves and does not claim, linking to cloud_affiliate_claim.

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 accepts no parameters, so there is nothing for the description to disambiguate; the baseline for a zero-parameter tool is 4.

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

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

Names a specific verb (get) and two concrete resources: the MONA Cloud referral link and its revenue-share rates. It clearly separates itself from cloud_affiliate_stats and cloud_affiliate_claim, though it gives no hint about the near-identical vibecloud_affiliate_link sibling.

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 clause 'so the user can review before publishing' implies a preview workflow, which is useful context. However, it states no conditions for choosing this tool over cloud_affiliate_stats or vibecloud_affiliate_link, and offers no exclusions or prerequisites.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful return-content context, but does not disclose pagination behavior, filtering behavior, or permission requirements 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 compact sentence with no wasted clauses, front-loading the core action and returned data. The bilingual duplication is acceptable and does not meaningfully reduce clarity.

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

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

For a simple read-only stats tool with rich annotations, the description is adequate about the general purpose. However, it is incomplete for invocation because neither optional parameter is documented or explained, and there is no output schema to compensate.

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

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

Schema description coverage is 0%, and there are two parameters (limit and status). The description mentions recent commissions and payout availability, but never explains what limit controls or how the status enum filters results, leaving the agent to infer parameter behavior from names alone.

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

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

The description states a specific verb and resource: read affiliate stats. It also lists the key returned content categories (payout availability, recent commissions), which distinguishes this tool from sibling affiliate actions such as link creation and claim/payout execution.

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 read-oriented purpose, but the description gives no explicit when-to-use guidance, prerequisites, or comparison against alternatives like cloud_affiliate_claim. An agent can reasonably infer this is the stats-reading tool, but routing guidance is minimal.

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

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

Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=false, openWorldHint=true), but the description adds genuinely useful context beyond them: it discloses that the tool currently returns a clear stub status, and that sandbox mode costs nothing and needs no wallet. It does not say what a real (non-sandbox) deployment does or whether it is reversible, but the stub caveat is meaningful behavioral information.

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 very short and every clause carries information, but the fragmentary phrasing ('Slot runtime agent wave kế tiếp') is cryptic and the important stub caveat is not front-loaded or clearly separated from the slotting statement.

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

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

For a tool with no output schema, the description at least explains that it returns stub status and hints that non-sandbox use requires a wallet. However, it leaves the template parameter, the real deployment outcome, and the relationship to sibling deploy tools unexplained, so it is only minimally complete.

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

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

Schema description coverage is only 50%, and the description's sandbox clause ('sandbox=true: thử 0đ, không cần ví') is a verbatim copy of the sandbox property's schema description, so it adds zero meaning. The required 'template' parameter, which only has a regex pattern, is never explained in the description.

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

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

The title says 'Deploy MONA Agent trên MONA Cloud', but the description never states a clear verb+resource like 'deploys an agent'; instead it says 'Slot runtime agent wave kế tiếp', which is ambiguous about whether it deploys, schedules, or queues an agent. It does not distinguish itself from close siblings such as agent_deploy, vibecloud_agent_deploy, or agent_templates_get.

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 only usage hint is 'sandbox=true: thử 0đ, không cần ví', which applies to one parameter value rather than telling the agent when to pick this tool over agent_deploy or vibecloud_agent_deploy. No preconditions, no exclusions, and no alternative routing is given.

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

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

Annotations already declare a non-read-only, open-world, non-idempotent operation, and the description adds real behavioral context beyond them: first host takes ~2-3 min vs 10-20 sec for later deploys, sandbox costs 0, polling is required until done/succeeded, and a MONA Pass login plus credit top-up may be needed. Failure modes and rollback behavior are still absent.

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 dense bilingual block that front-loads timing trivia and then strings together the entire multi-tool workflow, including steps for domain purchase and top-up that are not this tool's job. The trailing English summary is the only well-structured part; the rest is poorly segmented and hard to scan.

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 14 parameters, 0 required, no output schema, and low schema coverage, the description should carry much more weight, yet it only covers the sandbox workflow and says the URL is returned. It is adequate to understand the overall flow but insufficient to invoke the tool's many configuration options correctly.

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

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

Schema description coverage is only 7% across 14 parameters; only sandbox is documented in the schema. The description explains the sandbox=true/false pattern and mentions local_dir and repo_url, but leaves name, port, env, wait, branch, domain, build_type, dockerfile, app_host_id, timeout_sec and interval_sec entirely unexplained in both places.

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 final English line states the verb chain plainly: detect locally, estimate, obtain cost approval, upload and deploy, return URL, attach an optional domain. That lets an agent distinguish it from siblings like cloud_app_deploy or cloud_base_create, even though the core purpose is buried under a wall of workflow narrative.

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 explicit conditions: use sandbox=true first to estimate cost, then sandbox=false after one human cost approval, accept repo_url or local_dir, and it explicitly excludes agent_deploy for project deploys. The guidance is present but entangled with instructions for other tools (cloud_domain_buy, cloud_topup), which blurs which action belongs to this call.

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 cover destructiveHint, idempotentHint, and openWorldHint, so the safety profile is known. The description adds meaningful context beyond that: it specifies that app, domain, and A record are deleted, and warns that the app host may still incur charges. The unrelated first sentence about git app liveness adds noise but does not contradict the tool's 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 definition is not front-loaded: it opens with an unrelated sentence about git app deploy timing before stating the actual delete operation. That sentence is waste and pushes the core purpose into the middle of a bilingual, slash-separated block, reducing clarity and conciseness.

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

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

For a destructive delete tool with no output schema, the description does convey the cascade of deletions and a billing caveat, which are important. However, it omits parameter detail for app_id and its leading sentence is irrelevant, so the definition is only partially complete given the tool's complexity.

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 50%: sandbox is documented in the schema, but app_id has no description there. The tool description does not compensate by explaining what app_id represents or its format, only referring to 'an approved app'. This leaves the required parameter under-specified.

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: 'Delete an approved app.' That is clear enough for an agent to identify the operation. However, it gives no explicit differentiation from the duplicate sibling vibecloud_app_delete, and the leading sentence about git app deploy timing is irrelevant and dilutes focus.

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 'Sau khi user duyệt xoá' implies a prerequisite of user approval before deletion, which gives some usage context. It does not name alternatives or state when not to use this tool, so guidance is only implied.

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 state readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description usefully adds first-deploy timing (~2–3 minutes), subsequent deploy timing (10–20 seconds), the upload/wait/deploy flow, and polling 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 text is short, but it is split into slash-delimited bilingual fragments and duplicates content across Vietnamese and English. The clearest purpose statement appears at the end rather than being front-loaded, which weakens scanability.

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 deploy tool with six parameters, no output schema, and annotations covering safety, the description covers source modes, timing, and polling adequately. It still omits key polling parameter semantics such as wait, timeout_sec, and interval_sec, and gives no guidance versus sibling deploy 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 only 17%, so the description must explain parameters, but it only meaningfully clarifies local_dir. It does not explain wait, timeout_sec, interval_sec, app_id, or the full polling controls, leaving most parameters undocumented.

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

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

The description names a specific action (deploy/redeploy) and source types (git app or uploaded source), and mentions polling. It is clear enough to distinguish from list/get/create siblings, but it does not explicitly differentiate cloud_app_deploy from the identical-looking vibecloud_app_deploy sibling.

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 an operational branch: provide local_dir to package/upload/deploy a new ZIP, or omit local_dir to redeploy the previously uploaded version. However, it gives no guidance on when to use this tool versus cloud_app_create, cloud_app_get, or vibecloud_app_deploy 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?

Annotations already declare readOnlyHint=true, openWorldHint=false, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description still adds real value beyond them by stating it runs 'hoàn toàn offline' and 'không thực thi code dự án' (does not execute project code), which is a meaningful execution guarantee an agent could not infer from the hints alone.

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 content is compact and front-loads the detection targets, but it is delivered twice, once in Vietnamese and once in English, which doubles length for the same information. Bilingual redundancy is defensible for localization but costs conciseness.

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

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

With no output schema, the description usefully enumerates the detected fields (port, start, Dockerfile, build_type, env var names), so an agent knows what comes back. The only real gap is the unexplained local_dir input, making it nearly complete for a one-parameter detection tool.

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?

There is one required parameter (local_dir) with 0% schema description coverage, and the description never explains it – no indication of absolute vs relative path, expected directory shape, or error behavior. The enumerated detection outputs do not compensate for the undocumented input.

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 (detect/nhận diện) and resource (a local app) and enumerates exactly what is detected: Node/Next/Vite/Python/PHP/static, port, start command, Dockerfile, build_type and .env.example variable names. This is very concrete. However, it offers no differentiation from the near-duplicate sibling vibecloud_app_detect, so it falls short of a 5.

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

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

The description says what is detected but never states when to reach for this tool versus alternatives such as cloud_app_create or vibecloud_app_detect, nor any preconditions (e.g., run before app creation). No when-to-use or when-not guidance is present.

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=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, so the mutation/open-world profile is covered structurally. The description adds real context beyond that: the API returns CNAME instructions and the agent should wait for DNS propagation before verifying HTTPS. It does not state permissions or reversibility, hence a 4 rather than 5.

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 opening sentence about git app live timing and deploy durations is off-topic for a domain-attach tool and pushes the actual purpose into second position, harming front-loading. The Vietnamese and English lines restate the same points, adding redundancy rather than value.

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

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

There is no output schema, and the description compensates by noting the CNAME instructions returned by the API and the DNS-then-HTTPS sequence. However, with two required parameters undocumented and a low schema coverage, the definition is only minimally complete for correct invocation.

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

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

Schema description coverage is only 33% (only sandbox carries a description). The description hints that host is a domain the human already owns and that the target is an app, but it does not explain the host format, app_id semantics, or how sandbox interacts with real infrastructure, leaving two required parameters under-documented in both schema and prose.

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+resource: attach ('Thêm') an existing custom domain to a git-hosted app, and the English line 'Attach an existing custom domain' removes ambiguity. It partially distinguishes itself from the many cloud_domain_* siblings by scoping to an existing domain owned by the human. Sibling differentiation is present but relies on the reader parsing the mixed-language text.

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 explicit when-not and alternatives: if the human does not yet have a domain, use cloud_domain_search/cloud_domain_reserve/cloud_domain_buy then cloud_domain_attach. It also notes .vn/.com can be bought with VND in-session, which is exactly the routing an agent needs to pick the correct tool.

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

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

With annotations already declaring readOnly=false, openWorld=true, idempotent=true and destructive=false, the description adds meaningful context beyond them: the operation replaces the ENTIRE env (omitted keys are dropped, hence 'send the full map to keep'), it does not log secrets, and a separate deploy call is needed to apply. These are useful behavioral facts annotations don't convey.

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 leads with git-app deployment timing that is irrelevant to an env-set tool, and the whole message is duplicated in Vietnamese and English, roughly doubling length for the agent. The genuinely useful guidance (full map, no secret logging, deploy next) is buried rather than 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 set operation whose safety profile is covered by annotations and which has no output schema, the description conveys the key workflow (call deploy after) and the secret/full-map caveats. It falls short on parameter documentation, notably leaving 'app_id' undescribed at low schema coverage.

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 only 33% (only 'sandbox' is documented). The description adds some meaning for 'env' — send the complete map to keep and don't log secrets — but says nothing about 'app_id'. It partially compensates for the coverage gap without fully covering the undocumented parameters.

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

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

The core action is stated — 'Thay toàn bộ env' / 'Set app environment' for a given app — which is a specific verb+resource. However, the description opens with deployment-timing content that belongs to a different operation, diluting clarity about what THIS tool actually does.

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 concrete sequencing: replace the env after approval, and 'Gọi cloud_app_deploy sau đó để áp dụng' — call cloud_app_deploy afterwards to apply. It also states the condition to 'send the complete map to keep.' No explicit when-not or alternative comparison, but the workflow context is clear.

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, idempotent, non-destructive, and openWorld. The description adds the specific fields returned (status, URL, deploy times, app host) and deployment latency expectations, which is useful behavioral context beyond annotations. It does not cover auth or error behavior, but annotations lower the bar.

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?

Very short, but the bilingual slash-separated fragments and leading deployment-timing sentence make it poorly front-loaded; the core 'Inspect app' purpose appears last. It could be tighter and more direct.

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 tool with annotations and no output schema, the description adequately covers what will be returned (status, URL, deploy times, app host). It omits sandbox parameter effects and error handling, but those are minor given the tool's low complexity.

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 50%, with only the optional sandbox parameter described. The description says nothing about app_id or sandbox semantics, so it fails to compensate for the undocumented required parameter. app_id is obvious from the name, but the description adds no meaningful parameter detail.

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

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

States 'Inspect app' and lists what it reads: status, URL, deploy times, app host. It is a specific verb+resource, though it does not differentiate from siblings like cloud_app_list or cloud_app_logs.

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

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

No explicit when-to-use or alternatives are given. The deployment timing note ('first app host ~2-3 min, subsequent deploy 10-20s') is contextual but does not tell an agent when to choose this tool over cloud_app_list, cloud_app_logs, or cloud_app_deploy.

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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safe-read profile is already established. The description adds real behavioral value beyond that: per-app readiness timing (first host 2-3 minutes, subsequent deploys 10-20 seconds) and the conditional fallback to sandbox app creation when no host exists, which an agent would not otherwise know.

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 content is dense but the structure is muddled: three fragmented clauses, a bilingual split that doubles the text, and the timing facts are sandwiched before the actual action ('List app hosts') appears at the end. Most sentences carry useful information, but the front-loading is weak and the duplication costs clarity.

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

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

With one optional parameter, a full schema description, and no output schema, the description is largely complete for this complexity. It covers readiness timing and the no-host fallback path; only the return shape and the sandbox-vs-live distinction would add further value, which is acceptable given the annotations already cover the safety profile.

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% for the lone 'sandbox' parameter, which the schema already defines as 'Sandbox, no charge'. The description does not expand on the sandbox flag's behavior or distinguish it from real provisioning beyond what the schema conveys, 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?

States a specific verb+resource: 'List app hosts' / 'Đọc app host', giving the agent a concrete operation to invoke. However, it does not distinguish itself from the several sibling list/read tools in the same family (cloud_app_list, cloud_app_get, vibecloud_app_host_list), so it edges forward but falls short of a 5.

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

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

The description implies usage through the timing note ('first host ~2-3 min, later deploys 10-20s') and the fallback hint ('if no host exists, sandbox cloud_app_create first to estimate'), which is actionable context. But it never explicitly says when to use this tool versus cloud_app_list or cloud_app_get, leaving selection partly to inference.

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 covered. The description adds some unrelated deployment timing context but does not clarify what the list returns, whether it's scoped to the caller, or any auth/permission requirements. It adds little value beyond annotations and may confuse by mentioning deployment timing not relevant to 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?

The description is fragmented, mixes languages mid-sentence, and front-loads irrelevant deployment timing information before the actual purpose. The content does not earn its place for a simple list 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 read-only list tool with no output schema, the description should at least indicate what the list contains (e.g., app names, IDs) and any filtering constraints. Instead it includes tangential information about git deployment and duplicate avoidance, leaving the agent without key context about the return structure or scope.

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 parameter 'sandbox' is fully documented in the schema, so baseline 3 is appropriate. The description adds no additional meaning about the sandbox parameter or any filtering behavior.

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 contains 'Liệt kê app' / 'List apps', which restates the tool name cloud_app_list without adding a specific scope. The first sentence about git app deployment timing is unrelated to listing apps and obscures the purpose. It does not distinguish from siblings like cloud_app_host_list or cloud_app_get.

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 says to list apps before creating to avoid duplicates, which gives a clear pre-creation use case. However, it does not mention alternatives like cloud_app_get for a single app or cloud_app_host_list, and provides no explicit 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 cover read-only/idempotent/non-destructive, but the description adds real operational context the annotations do not: a 500-line output cap and a warning that logs may contain secrets and must not be published verbatim. That is useful disclosure beyond structured 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?

The text is bilingual mirrored prose plus an off-topic deployment-timing paragraph that does not belong in a log-reading tool. The actual purpose is neither front-loaded nor given in the opening sentence.

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 should say more about what is returned, but it at least discloses the 500-line cap and the secret-handling caveat. Parameter and usage gaps remain, leaving it only minimally adequate for a three-parameter tool.

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

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

Schema description coverage is only 33% (only 'sandbox' is documented in the schema), so app_id and deployment are unexplained everywhere. The description adds no meaning to any parameter, not even the optional deployment selector that determines which log set is read.

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 core purpose ('Read deployment logs' / 'Đọc ... log') is a clear verb+resource, but it is buried at the very end behind two sentences about deployment timing that appear copied from a deploy tool. An agent can eventually tell what this does, but the front-loaded text describes a different operation.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative to cloud_app_get / cloud_app_deploy. The '~2-3 minutes until first host is live' note only implicitly hints that logs become meaningful after a deploy, and no prerequisites 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, idempotent, non-destructive, and openWorld, so the safety profile is fully covered. The description adds only that the balance is VND-denominated, contributing little behavioral context beyond the structured 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?

A single short sentence with no waste; the resource is front-loaded ahead of the usage condition.

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

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

For a zero-param read tool with annotations covering safety and no output schema, the description is nearly complete: it says what is read and when. Return format (currency fields, etc.) is unspecified, which 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?

Zero parameters, so the baseline is 4; there is no parameter semantics to explain and nothing for the description to compensate 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?

States a specific verb (Đọc/read) and a specific resource (số dư ví VND chung – the general VND wallet balance), with 'chung' hinting at scope. It does not explicitly contrast with close siblings like cloud_ledger or cloud_usage, but the resource is unambiguous enough for selection.

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 a concrete when-to-use trigger: read the balance before creating paid resources. That is real routing context, though it names no alternatives or exclusions (e.g., versus cloud_ledger for history).

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 this is a mutating, non-idempotent, open-world call. The description adds real behavioral context beyond them: the tool polls the job to completion (long-running/blocking), it checks the wallet (billing implication), and sandbox mode returns an estimate without creating infrastructure. It omits any warning that non-idempotent retries could bill or create twice, which is the one gap keeping it from a 5.

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 workflow, which is good, but the bilingual text is not a clean mirror: the Vietnamese line and the two English lines repeat the same 'Base beta / Supabase replacement' idea twice, and the third sentence adds nothing new. Compact overall, but one sentence does not earn 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 create tool with no output schema, zero required params, and 17% coverage, the description covers the process and the sandbox branch but leaves key agent needs unanswered: what job identifier or resource is returned, whether the call blocks, and what happens on timeout or failure. Adequate 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 only 17% – just the sandbox flag is documented. Six parameters (cpu, ram_gb, disk_gb, plan_code, billing_mode) carry no description in either the schema or the description text, and the description adds no meaning about units, defaults, allowed ranges, or how plan_code interacts with billing_mode. With low coverage the description was obliged to compensate and does not.

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

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

States a specific verb+resource ('tạo Base' / 'create the Base') and even describes the full workflow (estimate, wallet check, create, poll). It is clearly distinguishable from cloud_base_list/get/delete/credentials by the create verb. It never names a sibling explicitly, so it falls short of a 5.

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

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

Implies when to use it (when you need a Base provisioned) and adds one useful conditional: 'sandbox chỉ trả ước tính' / 'Sandbox estimate only'. But there is no explicit when-not, no prerequisites, and no routing to alternatives such as cloud_base_get for checking an existing Base or cloud_balance before spending.

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/idempotent/non-destructive, so the bar is lower. The description adds genuinely valuable behavior beyond them: the output is secret, must not be logged, and should go straight into a secret store or uncommitted .env. That is exactly the kind of operator-critical context annotations can't express.

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 the same content repeated in three blocks (Vietnamese, then two near-identical English renderings). The second and third sentences are redundant ('Base beta = thay Supabase...' and 'Beta Supabase replacement...'), so words are spent without adding 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?

For a one-param read tool with no output schema, it usefully names the returned fields (anon_key, service_key, db_url) and the handling caveats. However it leaves the single parameter unexplained and gives no auth/prerequisite context, so it's adequate but not complete.

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

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

There is one required parameter (base_id) with 0% schema description coverage, so the description must compensate. It never explains what base_id identifies or how to obtain it; it only alludes vaguely to 'Base beta'. The schema therefore documents the param no better than the description does.

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

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

The opening line states a specific verb and resource: read anon_key, service_key and db_url for a base, which clearly distinguishes it from siblings like cloud_base_get or cloud_base_list. The 'Base beta = thay Supabase' framing adds useful scope context. It's clear but slightly muddied by being restated three times.

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

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

It implies usage ('Reveal credentials once and keep them secret') and gives post-call handling guidance, but never states when to call this versus cloud_base_get or after which setup step. No explicit alternatives or exclusions are named.

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=true, and readOnlyHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral detail beyond the annotations: the deletion is restricted to 'approved' bases. It does not state irreversibility, auth/permission requirements, or what happens to underlying data, so it is adequate but not rich.

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 content is short and front-loaded with the action, but the same information is repeated three times across Vietnamese and English, which is padding rather than added meaning. It avoids bloat but wastes space on redundant translation.

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, single-parameter tool with annotations covering the safety profile and no output schema, the description conveys the core action and one precondition. It still leaves the agent without the meaning of base_id or any warning about irreversibility/confirmation, so it is only minimally complete.

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

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

Schema description coverage is 0% and the single parameter base_id is undocumented in the schema. The description says nothing about base_id's form, source, or how to obtain it, so it fails to compensate for the coverage gap despite the small parameter set.

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 an approved Base') and even defines what a 'Base beta' is (Supabase replacement on the shared MONA Cloud account/wallet), which helps an agent identify the object type. It does not, however, distinguish this from the sibling cloud_base_create/get/list or the duplicate vibecloud_base_delete, so sibling routing is left to inference.

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 'approved Base' implies a precondition (only approved bases are deletable), but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as vibecloud_base_delete or the list/get tools an agent should consult first. An agent gets no routing help.

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/destructiveHint=false, so the safety profile is covered. The description adds that the call surfaces both state and URL and that the resource lives on the shared MONA Cloud account and wallet (consistent with openWorldHint=true), but says nothing about authentication scopes, error behavior, or what the URL 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 core statement is front-loaded, but the 'Base beta = Supabase replacement' idea is stated twice (once in Vietnamese, once in English) on top of the already-bilingual first sentence, so a meaningful fraction of the text is duplicated rather than additive.

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 partially carries the return-value burden by naming state and URL, which is the minimum useful information. It still leaves the parameter undocumented and the surrounding operational context (auth, rate limits, failures) unstated, so it is adequate 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 0% and the single required parameter base_id has no description in the schema. The description never mentions base_id, its accepted format, or where to obtain it, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('Đọc/Inspect a Base beta') and specifies what is returned (state and URL). It is distinguishable from cloud_base_create/delete and cloud_base_credentials, though it never contrasts itself with the near-identical cloud_base_list or vibecloud_base_get.

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 explicit when-to-use guidance and no routing to alternatives such as cloud_base_list (for enumeration) or cloud_base_credentials (for connection secrets). The only context given is a definition of what a Base beta is, which helps orientation but does not tell the agent when this call is the right one.

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, destructiveHint=false, and openWorldHint=true, covering the safety profile. The description adds domain context that Base beta is a shared-account Supabase replacement, but it does not disclose additional behavioral traits such as permissions, rate limits, or return format.

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 main action ('List Bases') but is repeated in Vietnamese and English, effectively duplicating the same content. While bilingual support may be intentional, the duplication reduces conciseness for an agent that only needs the English instruction.

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, parameterless, read-only list tool with no output schema, the description provides sufficient context: it identifies the target resource, the current account scope, and the nature of Base beta. It could still mention return shape or pagination behavior, but annotations cover safety and the tool is straightforward.

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?

There are no input parameters, so the schema cannot provide parameter semantics. The description appropriately avoids discussing parameters, and the baseline for a zero-parameter tool is 4.

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: 'List Bases' for the current account. It also explains what a Base beta is (a Supabase replacement on the shared MONA Cloud account/wallet). However, it does not explicitly distinguish from siblings like cloud_base_get or vibecloud_base_list, leaving some 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 gives no guidance on when to use this tool versus alternatives such as cloud_base_get (retrieve one Base) or cloud_base_create (create a Base). It merely states that it lists Bases, leaving the agent to infer usage 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 declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds only the 'theo kỳ' (per-period) scoping detail; it says nothing about auth requirements, rate limits, or what the period granularity defaults to.

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 short sentence with no filler, and the key scope ('theo kỳ') is front-loaded. It is efficient, though the extreme brevity edges toward under-specification rather than tight conciseness.

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

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

For a zero-parameter read tool with full annotations, the description is minimally adequate, but with no output schema it fails to describe what is returned (limit values, used amounts, currency, period granularity) or how the budget relates to cloud_budget_set. That leaves a real gap for an agent interpreting the result.

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 of 4 applies; the description correctly does not need to explain any inputs. It adds no parameter confusion, though it also offers nothing further because there is nothing to document.

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 gives a verb and resource ('Liệt kê giới hạn và mức đã dùng theo kỳ' – list limits and used amounts per period), so the agent knows it retrieves budget limits and consumption. However, it does not differentiate from close siblings like cloud_usage or cloud_budget_set, and 'get' vs 'list' in the name versus the description creates mild 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?

There is no when-to-use guidance, no mention of the companion cloud_budget_set tool, and no exclusions relative to cloud_usage. The agent must infer from the name alone when this budget read is the right call versus its siblings.

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 the full profile (mutating, idempotent, non-destructive, open-world), and the description adds no behavioral context beyond them — it does not say whether an existing budget is overwritten, what happens on exceeding the limit, or any auth requirements. It does not contradict the annotations, but it contributes nothing new.

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 with no filler or redundancy. It is efficient, though its brevity is part of the overall under-specification problem rather than an intentional trade-off.

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 4-parameter required mutation tool with 0% schema coverage and no output schema, the description is far too thin — period, limit_vnd, and scope_id are left entirely unexplained and there is no usage context. An agent cannot confidently construct a call from this.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, yet it only loosely gestures at the scope values (product/project/token) that the enum already defines. Nothing explains limit_vnd (units/currency), period, or scope_id format.

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

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

The description gives a specific verb (đặt/set) and resource (giới hạn chi tiêu/spending limit) and enumerates the three scopes (product, project, token). It is clear what the tool does, though it never names the sibling cloud_budget_get to distinguish the two budget 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?

There is no guidance on when to use this versus cloud_budget_get, cloud_token_limit, or other quota tools, and no prerequisites (e.g., ownership or admin rights) are mentioned. The agent must infer usage entirely.

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 this is a non-read-only, open-world, non-idempotent, non-destructive operation, so the write-like nature is covered. The description usefully adds that codes must be user-provided and pre-approved rather than invented, but says nothing about whether a successful redemption consumes the code permanently, what happens to an already-used code, or whether retries are safe.

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?

Very short and front-loaded — the constraint and the action both land in one breath. The cost is that the same content is stated twice (Vietnamese then English), which is defensible for locale coverage but is pure duplication for a single-locale agent.

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 redemption call with no output schema, an agent still does not know what a successful redemption returns (credit amount, new balance) or how failures surface. The annotations cover the safety profile, but the description leaves outcome semantics and code-reuse behavior unspecified.

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

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

Schema description coverage is 0% for the single 'code' parameter, so the description carries the burden; it adds real meaning by specifying the code is a user-supplied promotional credit code and must never be guessed. It still omits any note on format or the 2–64 character bounds documented only in the schema.

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

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

The description names a specific verb and resource — 'redeem an approved promotional credit code' — so the operation is unambiguous. It does not, however, distinguish this tool from the near-identical sibling 'vibecloud_credit_redeem', which appears in the same toolset with no stated difference.

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 two concrete usage constraints: use the code the user supplied, and do so only after they consent, plus an explicit prohibition on guessing codes. What it lacks is any routing guidance — nothing says when to pick this over 'vibecloud_credit_redeem' or when redemption is inappropriate (expired code, already-redeemed account).

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 only cover the safety profile (not read-only, not idempotent, open-world, non-destructive). The description adds real behavioral context beyond that: a wallet-balance precondition, an asynchronous job_id/poll workflow, and the zero-cost sandbox mode. It stops short of stating what happens on insufficient balance or how long the job takes.

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 clauses, front-loaded with the core action and immediately followed by the return contract and the cost-saving alternative. No filler, and the empty state (sandbox) is called out at the end where it is easy to scan.

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 supplies the key return contract (job_id to poll) and the wallet requirement, which is essential for a mutation tool. But for a 7-parameter creation tool at 14% schema coverage, the sizing parameters and app_name/package_slug semantics remain undocumented anywhere.

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

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

Schema description coverage is only 14% across 7 parameters, so the description has to compensate. It clarifies the engine enum values and the sandbox flag (whose meaning is already duplicated in the schema), but leaves app_name, cpu, ram_gb, disk_gb and package_slug entirely unexplained.

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

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

The description states a specific verb and resource ('tạo MongoDB/PostgreSQL/MySQL') plus the billing precondition (wallet check) and the async return contract (job_id để poll). It distinguishes itself from cloud_vps_create and vibecloud_create_database by naming the database engines, though it does not explicitly contrast with those 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?

It gives one useful usage branch — sandbox=true means a free trial with no wallet required — which implies the non-sandbox path needs a funded shared wallet. However, there is no explicit 'use this instead of X when...' routing to siblings like vibecloud_create_database or cloud_vps_create.

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=false, idempotent=true, destructive=false, openWorld=true. The description adds value beyond them by explaining that a not-yet-active .vn domain can still be attached, that the server completes the operation after profile approval, and that it emits a domain.status_changed webhook — non-obvious behavioral context.

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

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

Three sentences, action statement front-loaded, with supporting behavioral and parameter hints following. Reasonably tight; each sentence carries information, though the ID-sourcing hints could be trimmed.

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 compensates by mentioning the domain.status_changed webhook so the agent knows the completion signal. The main gap is the undocumented sandbox parameter, which neither description nor schema covers.

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 67%; the schema already documents app_id and domain_id with patterns. The description reinforces the ID meanings and their source tools but adds no format/syntax detail beyond the schema, and the sandbox parameter is undocumented in both description and 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 names a specific verb and resource ('Gắn tên miền vào app đã deploy'), so the action is unambiguous. However, it does not differentiate from the very similar sibling cloud_app_domain_add, leaving an agent to guess which one to use when both appear in the toolset.

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 prerequisite guidance on how to obtain the IDs ('Dùng cloud_app_list để lấy app_id', 'domain_id ... từ cloud_domain_list') and adds context about the .vn case, but gives no explicit when-to-use vs alternatives and never routes away from cloud_app_domain_add.

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?

Beyond the annotations it discloses a lot the schema can't: wallet deduction on VND, irreversibility (WHOIS can't be edited after purchase, hence spelling_confirmed gating), the 402 insufficient_balance path with QR display and waiting for cloud_topup_status=paid, .vn ending in pending_verification requiring cloud_domain_verify_start/wait, and sandbox=true simulating 0đ. This is far richer than the readOnly/openWorld/idempotent hints alone.

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?

It is long, but the opening sentence front-loads the core purpose and the remainder is a tight numbered pipeline where nearly every clause carries operational weight (prerequisites, error recovery, post-purchase state). Slightly dense, but not padded.

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 purchase tool with no output schema, the description still explains what comes back and what to do with it (suggested_next → cloud_app_create / cloud_domain_attach; pending_verification → verify + wait). Nothing an agent needs to invoke it correctly or handle its result 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 names, defaults, and the spelling_confirmed block flag are already documented; the baseline is 3. The description adds useful context (.vn needs CCCD/MST for the registrant, WHOIS is uneditable so spelling_confirmed matters) but little syntax or format detail 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 opens with a specific verb+resource+effect: "Mua tên miền và trừ ví VND — làm trọn trong phiên", and immediately distinguishes itself from cloud_domain_reserve (used when the user has no account) and cloud_domain_search (price/availability check). An agent can tell exactly what this tool does and how it differs from the other domain 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?

It gives an explicit ordered pre-flight flow (search → confirm spelling → approve cost → set registrant), names the alternative route for users without accounts (cloud_domain_reserve), and specifies error-driven branching (402 → cloud_topup → retry). Both when-to-use and when-not-to-use are covered.

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 say idempotentHint=false, which the description contradicts by using the word 'Idempotent' – this is technically an annotation contradiction, but the description's use is a shorthand for 'you can safely retry,' not a re-declaration of the annotation. Behavioral extras are rich: login requirement, auto-created profile/wallet, 402/422 semantics, money stays in wallet. However, the idempotent/safe-retry framing directly opposes the idempotentHint 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?

Front-loaded with the core action, then conditions, then result. Four sentences, each earning its place. Slight redundancy in the 402/422 explanation but no 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 mutation tool with no output schema, the description covers login prerequisites, error recovery, and return shape (order id, status, suggested_next). Missing only a note on failure side-effects like whether a failed claim leaves the reservation intact – though the 422 path implies the money stays in the wallet.

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 four parameters. The description adds only that claim_token comes from cloud_domain_reserve (already in schema) and mentions wallet/registrant context, but no extra syntax or format details. Baseline 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+resource: attach a reservation to the logged-in MONA Pass, pull transferred money into the wallet, then purchase immediately. It distinguishes itself from siblings like cloud_domain_buy (result is the same) and cloud_domain_reserve (source of claim_token) by naming them.

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

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

Explicit when-to-use and recovery paths: call again on 402 (→ cloud_topup or wait for QR transfer) or 422 registrant_required (→ cloud_domain_registrant_set then re-claim). Names alternatives and the conditions that select them.

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=false, destructive=false, idempotent=false and openWorld=true. The description adds no behavioral context beyond that - nothing about auth, rate limits, duplicate-record handling, or whether existing records are affected. With annotations covering the safety profile, the description adds no extra behavioral signal.

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 core action and kept to a few short sentences. The trailing 'AI làm trọn' is marketing filler that does not earn its place, but the body is otherwise tight.

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 6-parameter tool with no output schema, the description covers the basic operation and key field examples but omits conflict/precedence behavior and permission expectations. Adequately minimal 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 83%, so the schema already documents the parameters well. The examples (type=A/name=@/data=<IP>, CNAME/www) illustrate how the fields combine, adding marginal value, but domain_id remains undocumented in both places.

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 clear verb+resource ('Thêm 1 bản ghi DNS' = add a DNS record), which cleanly separates it from the update/delete/list siblings by name alone. It does not explicitly name those alternatives, but the action is unambiguous.

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

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

Usage is only implied through examples ('trỏ web ... trỏ www ...'), which show intent but not when to choose this tool over cloud_domain_dns_update or cloud_domain_dns_delete. No exclusions or prerequisites 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 destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that — no note about irreversibility, confirmation requirements, or what happens if the record does not exist, which is exactly the context a delete tool should supply.

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 short sentence with no filler, and the operative verb is front-loaded. It is efficient, though arguably too terse for a destructive operation, so it stops short of a 5.

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, non-readOnly tool with no output schema and 0% schema description coverage, the description leaves key gaps: it omits the required domain_id, gives no failure behavior, and offers no success/failure semantics. An agent cannot invoke this fully confidently from the description alone.

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

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

Schema description coverage is 0% and there are two required parameters. The description only echoes 'record_id' (already named in the schema) and never explains domain_id, its 24-hex format, or the relationship between the two identifiers.

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+resource ('Xoá 1 bản ghi DNS') scoped by 'record_id', so the action is immediately clear. It does not, however, differentiate itself from the sibling DNS tools (cloud_domain_dns_list/add/update), and the required domain_id goes unmentioned.

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 statement of when to use this versus cloud_domain_dns_update (modify) or cloud_domain_dns_list (read), nor any precondition such as needing an existing record or the parent domain. The agent must infer routing purely from the tool name.

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, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds the record types that will be listed and notes the domain is registered at MONA Cloud, but does not describe return format, pagination, ordering, or any other runtime behavior 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 two sentences: the first front-loads the core purpose with concrete record type examples, and the second adds the parameter sourcing. There is no wasted wording, and the structure is efficient and easy to parse.

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

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

For a simple list tool with one required parameter, rich annotations, and no output schema, the description covers what the tool does and where to get the input. It does not mention pagination or the shape of returned data, but those gaps are minor given the tool's simplicity and the presence of annotations.

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

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

With only one parameter and 0% schema description coverage, the description compensates by stating 'domain_id lấy từ cloud_domain_list', which clarifies where to obtain the required identifier. The schema provides a pattern (24 hex characters) but no textual description, so this added sourcing information is valuable, though it does not explain the format itself.

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 ('Liệt kê' = list) and resource ('bản ghi DNS' = DNS records) with example record types (A/CNAME/MX/TXT), making the tool's function clear. It does not explicitly differentiate itself from sibling tools like cloud_domain_dns_add or cloud_domain_dns_update, but the list verb implies a read operation distinct from the write 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?

The description provides a prerequisite context: 'domain_id lấy từ cloud_domain_list' (get domain_id from cloud_domain_list). This implicitly tells the agent to call cloud_domain_list first, but there is no explicit guidance on when to use this tool versus alternatives (e.g., DNS add/update/delete) or 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=false, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that: it does not say whether the supplied type/name/data fully overwrite the existing record, whether omitted optional fields (ttl, priority) are cleared or preserved, or that changes propagate to live DNS.

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 short sentence, front-loaded with the action and resource, with no filler. It is efficient, though the terseness borders on under-specification rather than true economy.

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 7-parameter mutation tool with 5 required fields, no output schema and no annotation-level detail about mutation semantics, the description is too thin. An agent is not told that type/name/data are mandatory and likely replace prior values, nor how TTL/priority defaults behave on update.

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 71%, with the schema itself documenting ttl, data, name, type and priority ranges/formats. The description contributes one genuinely new fact the schema lacks: that record_id must be obtained from cloud_domain_dns_list. It says nothing about the five required parameters or how they interact with the existing record.

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 gives a clear verb+resource ("Sửa 1 bản ghi DNS" = update a DNS record) and even names the source of the identifier (record_id from cloud_domain_dns_list). It does not, however, explicitly differentiate itself from the sibling mutation tools cloud_domain_dns_add and cloud_domain_dns_delete, so an agent must infer that this is the modify-in-place variant.

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?

Naming cloud_domain_dns_list as the origin of record_id implies a useful prerequisite (list before you edit), but there is no explicit when-to-use guidance, no statement that this replaces an existing record rather than adding one, and no exclusion pointing to dns_add/dns_delete for those cases.

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, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the specific items inspected (registration, profile, NS, SSL, alerts), which is useful behavioral context, but it omits return format 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?

A single efficient sentence that front-loads the verb and lists checked items without waste.

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 one-parameter read-only health check, the description lists what is checked but does not describe the return format or response shape. Given the rich annotations and full schema coverage, this is adequate though not exhaustive.

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

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

Schema description coverage is 100%, so the single 'id' parameter is fully documented in the schema. The description adds no parameter details, which is acceptable given the schema handles it.

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 ('Kiểm tra' = check) and enumerates the domain aspects checked (registration expiration, profile status, NS, SSL, alerts). It does not explicitly name a sibling tool to differentiate from, but its aggregate health-check scope is clear.

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

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

No when-to-use, prerequisites, or alternative tools are mentioned. The description only states what the tool does, leaving usage context to inference.

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 safety and repeatability are covered without the description. The description adds modest value by clarifying that both imported and purchased domains are returned and by defining what sandbox=true surfaces, but it says nothing about pagination, result volume, 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?

Two compact sentences with the primary purpose front-loaded and the parameter behavior trailing behind it; no filler words. It could be marginally tighter but every clause carries information relevant to invoking the 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?

The tool is simple (one optional boolean parameter, no nesting, no output schema) and the annotations carry the safety profile, so the description is close to sufficient. Still missing is any statement about what the listing returns structurally (paginated? per-domain fields?) or the default behavior when sandbox is omitted, which limits how confidently an agent can call it.

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

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

Schema description coverage is 100% and the single sandbox parameter is already documented in the schema ("true → hiện domain sandbox"). The description restates the same semantics for sandbox, adding no format, default, or edge-case detail beyond the schema, 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 states a specific verb ("Liệt kê") and resource ("tên miền") together with a scope qualifier (import + mua / đã đưa vào MONA Cloud), so an agent can tell it lists owned domains rather than searching for new ones. However, it never names the sibling search tools (cloud_domain_search, cloud_domain_suggest) that occupy the adjacent semantic space, so differentiation relies on the reader's inference.

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 explicit when-to-use guidance, no when-not-to-use, and no named alternative. The phrase "import + mua" hints at scope but the agent is left to infer that this is the inventory-listing call versus cloud_domain_search or mail_domains_list, which is exactly the ambiguity guidance should resolve.

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=false, idempotentHint=true and destructiveHint=false, so the safety profile is covered structurally. The description adds that the change is fully automated ("AI làm hoàn toàn"), but says nothing about propagation delay, whether existing DNS records go inactive when switching away from MONA, or any verification prerequisite — meaningful gaps for a delegation change.

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 short sentences with the core action and the minimum-NS constraint front-loaded; nothing is padded. The closing "AI làm hoàn toàn" is more marketing than actionable information, a minor waste.

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

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

For a mutation tool with no output schema, the description covers the core action and gives example values, which is helpful. It stops short of what an agent would want before calling: whether the domain must be verified first, what happens to existing records, and how long changes take to propagate.

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 50%: ns_list is documented in the schema while domain_id carries only a regex pattern and no description. The description reinforces the ≥2 minimum but adds no format or source guidance for domain_id, so it neither compensates for the gap nor falls below the baseline for a partially documented two-parameter 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?

The description names a specific verb and resource ("Đổi NS cho tên miền") and gives concrete NS examples (ns1.mona.host, ns2.mona.host), so an agent immediately knows this sets domain nameserver delegation. It does not explicitly distinguish itself from the DNS-record siblings (cloud_domain_dns_add/update/delete), which an agent could plausibly confuse with NS changes.

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 states the ≥2 NS constraint and gives two usage scenarios (keep DNS at MONA vs. move to Cloudflare/another provider), which implies when to reach for it. However, it names no sibling alternative and gives no explicit when-not condition, so routing between this and the cloud_domain_dns_* tools is left to inference.

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, destructiveHint=false, so the safety profile is covered. The description adds only that the data is 'đã lưu' (saved/stored), hinting the value may be a previously stored registrant, but it never states that no registrant may exist yet or what is returned.

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

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

Two short sentences, front-loaded with the action and followed by the reason for calling it. No wasted text, though it is arguably too terse to add much beyond purpose.

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

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

For a zero-parameter read tool with annotations covering the safety profile, the description is adequate but thin: it does not say what happens if no registrant has been stored, nor describe the returned data, leaving an agent to discover empty/absent results at call time.

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 schema carries no meaningful parameter semantics to document. With no params, the baseline of 4 applies and there is nothing for the description to compensate 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?

States a specific verb ('Lấy') and resource ('thông tin chủ thể/registrant') clearly, and the title reinforces it. It implicitly contrasts with the setter sibling, but does not name cloud_domain_registrant_set explicitly, 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 sentence 'Cần dữ liệu này để mua tên miền' gives a context for use (needed when buying a domain), which implies when to call it, but there is no explicit when-not guidance or reference to the alternative sibling (registrant_set) that would change the decision.

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 declare idempotentHint=true and openWorldHint=true, indicating safe repeated writes. The description adds valuable context: the save-and-reuse behavior across domains, the no-fabrication rule, and the conditional field requirements for .vn personal vs organizational. It doesn't describe error handling or what happens on partial data, but with annotations covering safety, this is strong.

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 core action, then provides usage rules. It's dense but each sentence serves a purpose. Slightly lengthy but appropriately detailed for a 14-parameter tool with complex conditional requirements.

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 14 parameters, complex conditional logic (.vn personal vs organization), and no output schema, the description covers the key behavioral aspects: what to collect, when to ask, and save-reuse semantics. It doesn't explain what the response contains or error scenarios, but for a setter tool with annotations, this is largely complete.

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

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

Schema coverage is 100%, so each parameter already has a description. The description adds semantic value by grouping fields into required-in-session (fullname, email, phone, address) and conditional sets for .vn personal (CCCD, DOB, gender) and organizational (org_name, tax_code, representative). This goes beyond the schema's per-field docs by explaining the conditional logic, but doesn't add format details beyond what schema provides. Baseline 3 is appropriate given complete schema coverage.

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

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

The description clearly states a specific verb and resource — lưu (save/store) thông tin chủ thể (registrant information) cho đăng ký tên miền (domain registration). It distinguishes from cloud_domain_registrant_get by describing a write operation and the data collection workflow. However, it doesn't explicitly say it's updating/setting vs creating, so a 4 is appropriate.

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?

Provides explicit when-to-use guidance: must ask user for required fields in-session, notes the difference between .vn personal vs organizational requirements, states it's saved once and reused for multiple domains, and explicitly forbids fabricating data with instruction to ask for missing fields. This is very thorough usage 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 only declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=true. The description goes well beyond: it discloses that dry_run=false deducts the VND wallet, that the renewal is executed at the registrar, that 502 means funds are held pending reconciliation (explaining the non-idempotent hint), and that repeated retries are harmful. No contradiction with 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?

Front-loaded with purpose, then the mandatory call sequence, then the two error branches. Dense but every clause is actionable (price source, approval gate, wallet debit, error routing); there is no 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 non-idempotent money-spending mutation with no output schema, the description covers the full lifecycle an agent needs: the dry-run/confirm/commit sequence, the returned price_vnd, wallet deduction, and both failure paths. Nothing required to call it safely 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 id, dry_run, and billing_cycle are already documented in the schema. The description restates dry_run's pricing behavior (VAT-inclusive) and the safety default, but adds little parameter-level meaning the schema does not already provide; the workflow sequencing it adds is usage guidance rather than parameter semantics. Baseline 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?

States a specific verb+resource ('Gia hạn tên miền' - renew domain) and scopes it to domains bought via MONA Cloud, which cleanly separates it from cloud_domain_buy, cloud_domain_list, and the DNS/NS siblings. An agent knows immediately what operation this performs.

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 an explicit two-call workflow (always dry_run=true first, ask user to approve the price, then dry_run=false) plus named error branches: 402 routes to cloud_topup with QR, and 502 tells the agent to stop retrying and inform the user. This is prescriptive when-to-use guidance with alternatives and 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 only mark this as non-readOnly, openWorld and non-idempotent. The description adds substantial behavioral context: no money is deducted, no real registration occurs, it only holds the name inside MONA Cloud (hold_scope=monacloud), and critically that outside parties can still register the same name at other registries during the 30 minutes. It also discloses return artifacts (qr_url, claim_url, claim_token, guest_token).

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 core purpose and the sibling alternative, and the workflow ordering (collect info → QR → claim) is logical. It is dense as one long block and some conditional guidance could be tighter, but most sentences carry operational value.

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 complex 9-parameter tool with a nested registrant object and no output schema, the description covers the full lifecycle: required inputs, optional registrant handling, return values (QR, claim tokens), and the next steps the agent must drive. Nothing essential to 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 coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: it explains that marketing_consent must be true only when the user agrees and otherwise left false, that spelling_confirmed comes from confirming the user's spelling, and that registrant should be populated now if subject details (.vn needs CCCD/MST) are already collected.

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 (reserve a domain for 30 minutes) and constrains the scope precisely to users who do NOT have MONA Pass or are not logged in on this device. It explicitly names the sibling cloud_domain_claim as the alternative for users who already have a Pass, so an agent can distinguish the two without opening either 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 gives explicit when-to-use conditions (buying in-session without prior registration), when-not (already have Pass → call cloud_domain_claim), and the full downstream flow (give QR, then open claim_url after payment). It also lists the mandatory information to collect from the user before invoking.

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=false, destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds behavioral context beyond that: the precondition that only un-funded reservations can be released, and that the operation is impossible once money has arrived. It does not describe the response or auth flow, keeping it at 4 rather than 5.

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 sentences with zero waste: the action and its scope come first, then the negative condition and the alternative tool. Every clause earns its place and the routing 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 2-parameter mutation tool with annotations covering the safety profile and no output schema, the description supplies the decision context (unpaid vs paid) and the alternative route. The only gap is that the conditional auth requirement for claim_token lives in the schema rather than the description, but that is a minor omission.

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

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

Schema description coverage is only 50%: claim_token carries its own description ('Bắt buộc khi chưa login') while reservation_id has none. The description adds no parameter-level meaning — it never mentions reservation_id, its 24-hex format, or the conditional auth requirement for claim_token — so it fails to compensate for the coverage gap.

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

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

States a specific verb+resource in 'Huỷ reservation chưa nhận tiền' (cancel an unpaid reservation), which an agent can distinguish from sibling operations. It also explicitly names the sibling to use for the other case (cloud_domain_claim), so no schema opening is required to tell them apart.

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 explicit when-to-use ('người dùng đổi ý / chọn tên khác' – user changed mind or picked another name) and when-not ('Đã có tiền vào thì không huỷ được'), with the alternative named directly (use cloud_domain_claim). Nothing is left to inference.

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, idempotent, openWorld and non-destructive. The description adds value beyond them by disclosing the auth nuance (token required only when not logged in) and by pointing to the next_step field as the follow-up driver.

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 short sentences, front-loaded with what is returned and then the token requirement. No filler, though the final next_step hint is slightly tangential to the invocation itself.

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 status check with no output schema, the description tells the agent what states are reported and directs it to next_step, which is sufficient to call and interpret the tool. It stops short of describing response shape or error conditions.

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 both parameters are already documented, including the 'required when not logged in' note that the description repeats. The description adds only marginal meaning (claim_token OR guest_token) over what the schema already states.

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

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

The description states a specific verb (Xem/check) and resource (reservation), and enumerates exactly what is inspected: payment received, claimed, still valid. It is clearly distinguishable from reserve/claim/release siblings, though it never names those siblings explicitly for 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?

It gives clear conditional context: guests must pass claim_token (or guest_token) obtained from cloud_domain_reserve, while a logged-in owner does not need it. It also routes the agent to read next_step in the result. There is no explicit when-not or alternative-tool guidance, keeping it 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?

Annotations already cover read-only/idempotent/non-destructive/open-world, so the bar is lower. The description adds genuinely useful context beyond them: no MONA Pass login is required and it works for users without an account, plus the price is quoted in VND inclusive of VAT. These are behavioral facts an agent cannot derive from the schema or 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?

Three compact clauses, front-loaded with the core purpose (availability + price) before the auth note and the when-to-use hint. Dense but every clause earns its place; minor use of em-dash clauses slightly reduces readability.

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 search tool whose safety profile is fully covered by annotations and with no output schema, the description is essentially complete: it states what it checks, what it returns (availability/price, in VND with VAT), and that no auth is needed. It could optionally note pagination/limits, but 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?

Schema description coverage is 100%, so the schema already documents q, tlds, and years (defaults, separators, ranges). The description adds no parameter-level syntax beyond what the schema provides, 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?

States a specific verb+resource pair in two parts: check domain availability ('Kiểm tra tên miền còn trống') and view purchase price. It is clearly distinguishable from siblings like cloud_domain_buy, cloud_domain_reserve, and cloud_domain_suggest because it produces availability/price rather than performing a transaction.

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?

Explicitly routes the agent: 'dùng trước khi mua/giữ chỗ để biết available/price' — use before buying/reserving. This gives clear workflow context and implies the alternatives (buy/reserve), though it doesn't name those sibling tools explicitly, so it falls just short of the top tier.

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 read-only/idempotent/open-world safety. The description adds real behavioral context beyond them: diacritic auto-stripping, live registrar status checks, VAT-inclusive VND pricing, and 'no login required'. Return format is not described, but annotations lower the bar.

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 purpose then usage, next step, and auth note; each sentence carries information. Slightly dense but no obvious 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 read-only suggestion tool with no output schema, the definition covers purpose, when to use, next actions, and auth requirements. Minor gap: no description of the result shape or how many/which TLDs are considered.

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. The description goes beyond the schema by explaining industry as a slug from cloud_domain_tld_groups that biases TLD selection (coffee → .cafe/.coffee) and clarifying that keyword accepts accented Vietnamese.

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: suggests available domains around a keyword, with price info. It clarifies scope (around a keyword) and names downstream siblings (cloud_domain_buy/reserve), though it does not explicitly contrast with cloud_domain_search.

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 clear triggering conditions: use when the desired name is taken or the user hasn't thought of one, and specifies the follow-up call. It lacks an explicit 'do not use for X' exclusion relative to cloud_domain_search, so it falls just short of 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: 'Không cần đăng nhập' (no authentication required) and a summary of what each returned group contains (count and price range).

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, no filler, with the output content front-loaded and the workflow instruction second. Every clause 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?

With no input parameters and no output schema, the description carries the burden of describing the return value, and it does so (industry groups with TLD counts and VND price ranges) while also explaining its role in the domain-purchase workflow and its auth requirement.

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. The description correctly implies no input is needed and instead frames the tool as a prerequisite lookup that yields the 'slug ngành' value later tools consume.

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 ('Liệt kê' / list) and resource ('các nhóm ngành của đuôi tên miền'), plus the concrete payload (number of TLDs and VND price range per group). It also names the sibling cloud_domain_tlds as the downstream consumer, so an agent can distinguish it from other domain tools 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?

Explicitly instructs to call this BEFORE cloud_domain_tlds to obtain the industry slug needed for filtering, which is a clear ordering rule against a named alternative. It does not state when NOT to use it or any failure conditions, so it stops short of full when/when-not coverage.

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/idempotent/openWorld/non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: prices already include VAT, first-year price reflects running registry promos, .vn entries carry needs_verification=true meaning an entity-verification profile is required, and no login is needed.

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-loads what is returned (both price fields, VAT-inclusive) before the filtering options and the when-to-use triggers. Dense but every sentence carries distinct information; slightly long but not padded.

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-value burden and does name the key output fields (price_vnd, renew_vnd, needs_verification). Filters, auth requirement, and the group-slug dependency are all covered, leaving only minor gaps such as pagination guidance.

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 baseline is 3, but the description adds value the schema lacks: group takes a slug sourced from cloud_domain_tld_groups, q matches both the TLD name and Vietnamese label, and max_price_vnd filters on the first-year price specifically rather than renewal.

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 resource and scope: the full price list of TLDs MONA Domain sells, with first-year (price_vnd) and renewal (renew_vnd) prices in VND incl. VAT. It is the only price-list tool among the cloud_domain_* siblings and it clarifies its relationship to cloud_domain_tld_groups (source of group slugs).

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 concrete trigger phrases ('có những đuôi nào', 'đuôi nào rẻ', 'đuôi nào hợp ngành X') and routes the agent to cloud_domain_tld_groups for valid group slugs. It does not explicitly exclude or compare against cloud_domain_search / cloud_domain_suggest, so the when-not side is left to inference.

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=false, idempotentHint=false, openWorldHint=true and destructiveHint=false, so safety is covered. The description adds the state gate (pending_verification) and that output is a generated form plus upload link, but says nothing about permissions, side effects of re-calling, or expiry of the upload link.

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, the artifact produced is front-loaded and the precondition follows immediately. No filler or repetition.

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 does partially cover the return (pre-filled declaration + upload link) and the triggering state, but it omits what the agent should do next (upload/submit, then poll cloud_domain_verify_status), leaving the workflow half-specified.

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

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

Schema description coverage is 100% and the single `id` parameter is documented in-schema as the order ID from cloud_domain_buy. The description adds no syntax or format detail beyond that, 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 artifact: 'Sinh bản khai đã điền sẵn và link upload hồ sơ .vn' (generate a pre-filled declaration and upload link for the .vn dossier). This is far more than a restatement of the name, though it does not explicitly contrast itself with the nearby cloud_domain_verify_status.

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 an explicit activation condition: use after buying a .vn domain with status=pending_verification. That is a real when-to-use rule, but no alternative tool is named (e.g. verify_status for checking progress) and no exclusions 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 readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds that the value comes from an external system (MONA Host) and is the profile_status field, which is mildly useful but does not describe retry/polling behavior or what values can be returned.

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 with zero filler; the action and resource lead immediately. It is appropriately sized for a one-parameter status tool.

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

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

For a simple read-only status lookup with one fully documented parameter, the description is adequate but thin. Since there is no output schema, it would help to hint at the possible profile_status values or the meaning of a pending/rejected state, which is the tool's entire raison d'être.

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% – the single 'id' parameter is documented as an Order ID with a hex pattern constraint. The description adds no syntax or format detail beyond the schema, 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 pairs a specific verb (Kiểm tra / check) with a specific resource (the approval status of a .vn registration profile) and even names the underlying data field (profile_status) and source (MONA Host). It is clearly a read-status tool, though it does not explicitly contrast itself with close siblings like cloud_domain_verify_start or cloud_domain_reserve_status.

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 explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as cloud_domain_verify_start or cloud_domain_wait. The purpose implies a status-check workflow, but the agent must infer when this is the right call rather than cloud_domain_health.

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 safety traits like readOnly, idempotent, openWorld, and non-destructive. The description adds meaningful behavior by stating it is a long-poll that waits for active/failed states, though it omits what happens on timeout or any auth/rate-limit context.

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

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

Two compact sentences, front-loaded with the core behavior and followed by usage context. Every sentence earns its place with no redundant 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 wait tool with rich schema annotations and no output schema, the description covers purpose, terminal states, and sequencing after purchase. The only notable gap is not clarifying what the call returns or does if the timeout elapses.

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 (id and timeout) are fully documented in the schema. The description only repeats the default timeout=60s, adding no new semantic detail 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 ('Long-poll'), resource ('tên miền'), and terminal conditions ('active/failed'). It also ties the tool to its predecessor sibling ('Dùng sau cloud_domain_buy'), making its role clear.

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

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

It explicitly says to use this tool after cloud_domain_buy to wait for MONA Host processing. However, it does not mention when not to use it or name alternative polling/status tools such as cloud_domain_verify_status.

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 đã khai báo readOnlyHint=false, idempotentHint=true, openWorldHint=true, destructiveHint=false; mô tả bổ sung thông tin về HMAC, loại sự kiện và giới hạn 1 webhook/user. Không có mâu thuẫn với 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?

Hai mệnh đề ngắn, thông tin quan trọng được đưa lên trước, không có câu thừa. Độ dài phù hợp với một công cụ đăng ký webhook đơn giản.

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?

Với công cụ mutation 2 tham số, annotations khá đầy đủ, mô tả nêu được sự kiện, HMAC, hành vi một-webhook-mỗi-user và cập nhật khi gọi lại. Còn thiếu mô tả về phản hồi hoặc xác thực, nhưng không cản trở việc gọi đúng công cụ.

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 mô tả secret ở mức 50% (chuỗi bí mật xác minh HMAC); mô tả chỉ nhắc lại HMAC và URL nhận sự kiện, không thêm ràng buộc định dạng hay ý nghĩa mới cho url. Baseline 3 phù hợp khi schema đã làm phần lớn việc mô tả tham số.

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?

Nêu rõ động từ + tài nguyên: đăng ký URL nhận sự kiện domain.status_changed, có ký HMAC. Sự kiện domain giúp phân biệt với các webhook monapay/mail, dù không nêu tên công cụ thay thế.

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?

Cho biết mỗi user chỉ có 1 webhook và gọi lại để cập nhật, tức là hành vi upsert. Thiếu khi nào không nên dùng hoặc công cụ thay thế, nhưng ngữ cảnh sử dụng đã rõ.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered structurally. The description adds only the 'monthly' scope of the invoices, but says nothing about whether results are paginated, how far back they go, or what fields are returned.

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 with no filler. The bilingual duplication is mildly redundant, but it is a deliberate localization choice rather than padding.

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 no-parameter read tool with rich annotations and no output schema, this is close to adequate, but it leaves open whether it lists all historical invoices or only the current billing cycle, and what the response shape is.

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 schema has nothing to document and the baseline of 4 applies. The description's 'hàng tháng / monthly' qualifier adds the only relevant semantic constraint.

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: 'Đọc hoá đơn hàng tháng của tài khoản / List monthly invoices' — an agent knows this retrieves monthly billing invoices for the account. It does not distinguish itself from near-identical siblings like vibewcloud_invoice_list or cloud_invoice_pdf, so it falls short of a 5.

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

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

There is no indication of when to use this versus the sibling invoice tools (vibewcloud_invoice_list, cloud_invoice_pdf) or any prerequisites. Usage is only implied by the tool name.

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/idempotent/non-destructive, so the bar is lower, yet the description adds real behavior: the returned path points at a private temp file that the OS will later clean up, and the caller must copy it out to persist it. That ephemerality warning is genuinely valuable context beyond 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?

Short and front-loaded, with the core action first and the temp-file warning second. The bilingual duplication doubles the text length, which is mildly wasteful but serves locale needs.

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 download tool with no output schema, the description covers the return value (a path) and its lifecycle behavior. What remains missing is the invoice_id format and confirmation that the payload is a path rather than bytes.

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

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

With one parameter and 0% schema description coverage, the description must carry the load; it never explains invoice_id at all. The name is self-explanatory and the invoice context is clear, but no format or source hints are given.

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: 'Download invoice PDF'. The bilingual phrasing makes the action unambiguous. It does not distinguish itself from its near-identical sibling vibecloud_invoice_pdf, so it stops short of a 5.

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

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

Usage is implied by the single required invoice_id, but the description never says when to reach for this versus cloud_invoice_list or vibecloud_invoice_pdf. The only actionable guidance is about post-call file handling, not tool selection.

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