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

With no annotations, the description carries the full behavioral burden. It discloses the visual effect and interaction with the SUN source and recommends combining with 'tao_den', but it does not state whether it overwrites existing environment lighting, whether changes are reversible, or what side effects or output to expect.

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 purpose and then provides practical parameter guidance. It is somewhat verbose in the opening sentence but does not contain wasted 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?

For a tool with no annotations, no output schema, and 0% schema description coverage, the description covers the core visual purpose and 'cuong_do' semantics. However, it leaves the 'mau' parameter unexplained and does not describe mutation behavior such as replacement or reversibility, so it is not fully 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% for two parameters. The description fully explains 'cuong_do' with concrete values and visual scenarios, which adds meaningful semantics, but it completely omits the 'mau' (color) parameter, leaving half the 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 states a specific verb and resource ('Đặt ánh sáng môi trường') and clarifies that the tool acts as the sky casting light into the scene. It also implies a distinction from 'tao_den' by recommending they be used together for clearer lighting, though it does not directly name alternatives to this tool.

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 a clear usage context: without it, surfaces facing away from the SUN are dark, and it should be called with 'tao_den' for clearer lighting. It also provides scenario-based guidance for 'cuong_do' values (0.5, 1.0, 2.0), though it does not explicitly state when not to use the 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?

Without annotations the description carries the full burden, and it delivers real behavioral context: volume is measured directly from geometry and openings already-carved into stone are pre-subtracted, and results are grouped by component type plus total concrete and total masonry. It does not state read-only/non-mutating behavior explicitly, but the computation semantics are unusually well disclosed.

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

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

Three short sentences, front-loaded with the action, then the computation caveat, then the return contents. 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?

With no annotations and no output schema, the description must carry the return-value burden, and it does: per-component-type results plus concrete and masonry totals. Minor gap is that it doesn't say whether the model must be free of errors or what happens on an empty model.

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 there are no parameter semantics to document — baseline 4 applies. The description correctly focuses on behavior and output instead.

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 — extracting a bill of quantities (bóc khối lượng) from the already-built 3D model — which no sibling tool does (siblings are construction/creation tools like dung_tuong, khoet_cua). An agent can immediately tell this is the quantity-takeoff step.

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?

"từ chính mô hình 3D đã dựng" clearly signals the prerequisite: the model must already exist before calling this. It doesn't name alternatives, but none of the siblings perform a comparable function, so the 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?

No annotations exist, so the description carries the burden. It usefully discloses that engine names vary across Blender versions and that an invalid name produces an error listing valid names — genuine behavioral context. It does not say whether the setting persists beyond the session or applies to subsequent renders, which matters for a configuration-mutation tool.

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

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

Three short sentences, front-loaded with the core action, then engine guidance, then the error caveat. No filler, though the line breaks are a bit fragmented.

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 annotations, no output schema, and 4 undocumented parameters, the description should do more. It leaves 'mau_anh' unexplained, does not state persistence semantics, and gives no indication of what a successful call returns or changes.

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% across 4 parameters, so the description must compensate. It covers resolution (do phan giai) and engine conceptually but never maps them to 'cao'/'rong' or explains defaults, and 'mau_anh' (color management) is entirely 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 first sentence states a specific verb and resource: set resolution and render engine. That is enough for an agent to distinguish it from render_anh (which actually renders), but the description never names a sibling to sharpen the boundary.

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

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

It gives real decision guidance on engine choice (BLENDER_EEVEE_NEXT for speed, CYCLES for quality), which is more than implied usage. It never says when this tool should be called relative to render_anh or whether it must precede rendering, so there is no explicit when/when-not framing.

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

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

With no annotations, the description carries the burden and largely does: it discloses that code is statically scanned beforehand to block dangerous operations such as file deletion and system commands, and defines the return contract (assign to the variable 'ket_qua'). It also warns about cross-machine portability (node lookup by type, reading enum lists from bl_rna). Missing: sandbox/rate limits, timeout, Python version, or what happens when code is rejected — so not 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 one-line purpose, then safety/return contract, then portability notes. Every section earns its place and there is no filler, but the multi-block layout is slightly longer than strictly necessary for a single-parameter tool.

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

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

No output schema and no annotations, so the description must cover behavior — and it explains the safety scan and the ket_qua return mechanism, which are the two things an agent most needs. It does not mention execution timeouts, error surfacing, or available modules, leaving a small gap for a tool this open-ended.

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% (the sole 'code' parameter is documented only as a bare string), so the description must compensate — and it does meaningfully: the code is scanned before execution, results come back via the 'ket_qua' variable, and it gives concrete authoring guidance (query type not name, read enums from bl_rna). It stops short of stating language/import constraints, so 4 rather than 5.

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 ('chay Python bat ky ben trong Blender') and explicitly positions itself as the fallback escape hatch ('dung khi khong co tool san phu hop'). This distinguishes it cleanly from the whole sibling list of purpose-built tools without needing to open any schema.

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

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

Gives an explicit selection condition: use only when no purpose-built tool (the listed siblings like dung_tuong, tao_camera, render_anh) fits. That implicitly routes to alternatives, though it never states a hard when-not or list the exact siblings it supersedes. Clear context, no explicit exclusions — a 4.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only listing operation and explains the downstream purpose, but does not state behavior on invalid/missing paths, whether it is strictly read-only, or any output/error characteristics.

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 with the core action front-loaded, followed by the routing rationale. Efficient, though the trailing explanation is slightly loose rather than tightly scoped.

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 single-parameter read tool with no output schema and no annotations, the description gives purpose and sequencing but omits the parameter's meaning and any sense of the returned layer data, leaving noticeable gaps an agent must infer.

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 'duong_dan' is undocumented in the schema. The description only vaguely implies a DXF file ('trong mot file DXF') but never names or explains the path argument, so it does not 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 (liet ke layer trong mot file DXF) and adds scope value by explaining the layers reveal walls and columns. An agent can distinguish it from doc_mat_bang_dxf and the dung_* construction siblings without opening any schema.

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

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

Explicitly instructs to call this tool BEFORE dung_nha_tu_dxf, naming the alternative and the ordering rationale (each design unit names layers differently). It gives clear when-to-use context but no explicit when-not or error-handling conditions.

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

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

With no annotations, the description carries the full burden. It does disclose the important behavioral trait that nothing is created in Blender (non-destructive read) and that it returns lists of walls/columns, plus coordinate-unit semantics. However it omits return structure, error behavior for malformed DXF, and how layer_cot/layer_tuong affect results.

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?

Purpose is front-loaded in the first line, followed by a usage note and only the two parameters worth explaining. The short list format is easy to scan and no sentence is wasted, though a heading or tighter grouping could improve it slightly.

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 6-parameter, no-annotation, no-output-schema tool, the description is adequate but not complete: it never explains the shape of the returned wall/column data an agent must interpret, and four parameters are left to inference. The unit-scaling and region guidance are the strongest parts.

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%, so the description must compensate. It does a good job on 'vung' (explicit [x0, y0, x1, y1] format and the multi-floor-plan use case) and 'ty_le' (0.001 mm vs 1.0 m), but leaves 'goc', 'duong_dan', 'layer_cot' and 'layer_tuong' undocumented beyond their self-explanatory names.

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: reads a floor-plan DXF and returns the list of walls and columns ('danh sach tuong, cot'), explicitly noting it builds nothing in Blender ('chua dung gi trong Blender'). This implicitly separates it from siblings like dung_nha_tu_dxf and dung_tuong, though it never names an alternative, 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?

'Dung tool nay de kiem tra du lieu doc ra co dung khong truoc khi dung' gives a clear when-to-use: a dry-run/inspection step before committing to geometry construction. There are no explicit exclusions or named alternatives, but the context of use is unambiguous.

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

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

With no annotations, the description carries the full behavioral burden. It does add a genuinely useful behavioral trait: the stair is modeled as real construction rather than a solid block so extracted concrete volume matches reality. It says nothing about what object is created, whether it is undoable, permissions, or what happens on repeated calls with the same start point.

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 purpose, then parameter notes, then a behavioral footnote; paragraphs are short and each carries distinct information. Minor looseness in the example sentence, but nothing that should be cut.

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 9-parameter creation tool with no annotations, no output schema, and no schema descriptions, the definition is under-specified: the required start point and two of the geometry parameters are never explained, and there is no indication of what the tool returns or how the new element is identified. The geometric model is explained, but not enough to invoke it safely.

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% across 9 parameters, so the description must compensate. It does meaningfully define huong_do (degrees, 0=+X, 90=+Y), day_ban (thickness perpendicular to the incline), and the cao_bac*so_bac relationship, but it leaves ten, cao_do, rong_bac, rong_thang, and — critically — the single required parameter diem_dau entirely 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 first sentence names a specific verb+resource ('Dung cau thang betong mot ve') and immediately describes the geometry ('ban nghieng cong cac bac nam tren'), which is enough to distinguish it from the wall/floor/column/beam siblings. It does not explicitly contrast itself with those siblings, but the resource is unmistakable.

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

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

The description gives a validity constraint ('cao_bac nhan so_bac phai bang chieu cao tang') and an example, which helps a caller parameterize correctly, but it never states when to choose this tool over the alternatives (e.g. dung_dam, dung_san) or any precondition for invoking it. No when-to-use or when-not-to-use 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?

No annotations are provided, so the description carries the full burden. It says a column is drawn but omits units, whether it is added to the current layer, whether the operation is reversible, and what the result is. Only the vi_tri meaning is disclosed.

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

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

Two short sentences, front-loaded with the core action followed by the one parameter clarification. It is tight, though the brevity reflects under-specification rather than disciplined 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?

With 6 parameters, no annotations, no output schema, and 0% schema coverage, the description should explain units, defaults, and dimensions. It covers only the anchor point, leaving an agent unable to confidently supply the remaining arguments.

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% across 6 parameters, yet the description only explains vi_tri as the [x, y] center. The remaining five (cao, sau, ten, rong, cao_do) are undocumented in both schema and description, so the description 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: 'dung mot cot chu nhat' (draw a rectangular column), which distinguishes it from sibling draw tools like dung_tuong, dung_dam, dung_san. It does not explicitly name or contrast those siblings, but the resource 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?

There is no guidance on when to use this tool versus alternatives such as dung_tuong or dung_dam, nor any prerequisites (e.g., which layer/view it operates in). Usage must be inferred from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about units, coordinate system, whether it creates a persistent object, or how it interacts with the scene. For a mutation tool with zero annotation coverage this is a notable gap; the only disclosure is the meaning of one elevation parameter.

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 purpose and then the key clarification; every sentence earns its place with no filler. It is arguably too terse for a 6-parameter tool, but it is not bloated.

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 six parameters, no annotations, and no output schema, the description is far too thin. Units, coordinate format for diem_dau/diem_cuoi, the meaning of cao/rong, and the resulting object behavior are all absent, leaving the agent guessing on most inputs.

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% across 6 parameters, so the description must compensate, but it clarifies only cao_do_day (bottom elevation, not top). The other five parameters (cao, rong, ten, diem_dau, diem_cuoi) remain undocumented in both schema and description.

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

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

The description states a specific verb and resource ('Dung mot dam ngang' = draw a horizontal beam), which is enough to distinguish it from structural siblings like dung_cot (column), dung_san (floor), and dung_tuong (wall). It does not, however, explicitly name or contrast with any sibling, 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 statement of when to use this tool versus the many other draw_* siblings (dung_cot, dung_san, dung_mai, etc.), nor any prerequisites or context. The only guidance given is a parameter clarification, which is not usage routing.

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

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

With no annotations, the description carries the full behavioral burden and does not disclose anything about the operation itself — no note on required existing geometry, side effects, reversibility, or whether it needs a level/base to attach to. It only explains three parameter meanings, which is parameter semantics rather than behavioral disclosure.

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

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

Four short lines, purpose front-loaded, each subsequent line mapping to a parameter with no filler. Efficient and well-ordered, though extremely terse.

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 geometry-construction tool with no annotations and no output schema, the definition is under-specified: the required 'dinh' coordinate input and the 'day'/'cao_do'/'ten' parameters are never addressed, leaving an agent unable to call it correctly 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 coverage is 0%, so the description must compensate; it usefully defines kieu ('bang' vs 'doc'), do_doc (slope ratio, 0.02 = 2%), and vuon (overhang past the wall) — including an implicit enum the schema lacks. However, it leaves 4 of 7 parameters undocumented, including the required 'dinh' (apex points), plus day, ten and cao_do.

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 ('Dung mai betong' = build concrete roof), which is self-evidently distinct from siblings like dung_san (floor), dung_cot (column) or dung_dam (beam). It does not explicitly contrast with any sibling, but the resource 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?

No guidance on when to choose this tool versus alternatives (e.g. dung_san for a flat slab), and no prerequisites or workflow context. The remaining lines explain parameter values rather than usage conditions.

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

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

No annotations, so the description carries the full burden. It implies scene mutation (building walls and columns) but never states whether existing geometry is overwritten, whether a Blender connection is required, or what units/scene state results. Key behavioral facts are missing.

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 the action, followed by role and prerequisite. No filler, though it could be tighter.

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?

A complex 9-parameter mutation tool with no annotations and no output schema needs far more behavioral and parameter detail than provided. Layer selection, scale, and height semantics are all left for the agent to guess.

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?

Nine parameters with 0% schema description coverage, and the description explains none of them. Critical inputs like duong_dan (required), ty_le (scale), cao_tuong, layer_cot/layer_tuong, and dung_cot_luon are left entirely 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: reads a DXF floor plan and builds walls ('tuong') and columns ('cot') in Blender. The 'from DXF' scope also distinguishes it from sibling builders like dung_tuong and dung_cot, though it does not name those explicitly.

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

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

Explicitly tells the agent to call doc_mat_bang_dxf first to verify the data before invoking this tool, and frames the tool as the 2D-to-3D bridging step. Clear sequencing context, but no when-not guidance or discussion of alternatives.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the polygon needs at least 3 points and that the slab extends downward from cao_do, but it omits write-operation side effects, permissions, validation behavior, and return 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 compact and front-loaded: purpose first, then the key parameter constraints. Every sentence contributes directly and 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 4-parameter geometry-creation tool with no annotations, no output schema, and 0% schema coverage, the description is incomplete. It does not explain day or ten, coordinate units, return values, or side effects, leaving the agent to infer important details.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for dinh (ordered [x, y] ring, minimum 3 points) and cao_do (top-surface elevation with slab below), but leaves day and ten 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: building a concrete floor slab from a floor-plan polygon. It is clear what the tool creates, but it does not explicitly differentiate itself from sibling construction tools such as dung_tuong or dung_mai.

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 explains the required polygon input format but gives no guidance on when to use this tool instead of siblings, nor any prerequisites or exclusions. Usage is only implied by the tool's purpose.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a bulk creation operation, but says nothing about whether it clears or overwrites existing scene content, atomicity, error handling, or permission/rate considerations – key behavioral traits for a batch-build tool.

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

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

Purpose is front-loaded, followed by the necessary structure example and a targeted clarifying note about the wall index. The example block is large but earns its place because the schema itself is empty; little is wasted.

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

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

For a nested-object tool with no output schema and no annotations, the description covers the core structure well but only shows a representative subset of fields – it omits roof (mai), stairs (cau_thang) and other elements the sibling tools imply, and never states what the call returns. Adequate to start, but not complete for building an arbitrary full house.

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% with a single opaque object parameter (additionalProperties: true), so the description must compensate. It does so with a concrete JSON example enumerating the nested fields (ten, tang, cao_do, cao_tuong, san, tuong, cot, cua) and an explicit note that the door's 'tuong' value is a 0-based wall index. It stops short of exhaustive field documentation, so not a 5.

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 (dung/build) and resource (ca cong trinh / entire project) from a single description. It explicitly differentiates from the per-element siblings by noting it is 'nhanh hon goi tung tool' (faster than calling each tool), so an agent can tell it apart from dung_tuong, dung_san, dung_cot, etc.

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?

'Day la cach nen dung khi dung nguyen mot ngoi nha' gives a clear when-to-use condition (building an entire house) and implies the alternative (calling individual tools) for smaller scopes. It stops short of an explicit when-not or naming a specific sibling, so it is clear context rather than a full routing 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?

No annotations are provided, so the description carries the full behavioral burden for a creation/mutation tool. It never says whether the wall is appended to the current model, which layer it lands on, whether the operation is undoable, what happens if diem_dau/diem_cuoi coincide or cross existing geometry, or what identifier is returned. Only the geometric semantics of the inputs are disclosed.

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

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

The text is short, front-loads the purpose sentence, then presents a compact parameter glossary. Nothing is padded, though the parameter lines are telegraphic enough that some semantic edges (units for cao/cao_do, coordinate order for the point pairs) require inference.

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 6-parameter geometry-creation tool with no annotations and no output schema, the description covers most input semantics but leaves the operational envelope incomplete: no return value, no preconditions, no interaction with existing geometry. It is adequate to build a wall with sensible defaults, but not complete enough to predict side effects.

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

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

With schema description coverage at 0%, the description does the heavy lifting: it defines diem_dau/diem_cuoi as the [x, y] centerline endpoints in meters, explains day as wall thickness with typical values (0.22 load-bearing, 0.11 partition), and clarifies cao as height typically equal to story height plus beam depth, and cao_do as the base elevation. Only the optional 'ten' (name) parameter is left unexplained, but its meaning is self-evident.

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 in Vietnamese: draw a straight wall on the floor plan ('dung mot buc tuong thang tren mat bang'). This is clearly distinguishable from structural siblings like dung_cot, dung_dam, and dung_san by object type, though the description never names those siblings or explicitly contrasts itself with them.

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

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

There is no statement of when to use this tool versus alternatives such as dung_cot, dung_dam, or khoet_cua, nor any prerequisites (e.g., must a floor plan exist first, which layer is targeted, must a story level be defined). The only implicit guidance is that thickness conventions differ for load-bearing vs partition walls, which is parameter semantics rather than usage routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether assigning replaces an existing material, whether the object must already exist, what permissions or state are required, or what happens on failure, leaving a mutation tool's side effects opaque.

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 action front-loaded, but that brevity comes at the cost of under-specification rather than efficient density. It is concise without being informative.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter description coverage, the description is too thin. It omits prerequisites, replacement semantics, and error behavior, all of which the agent must know before calling.

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

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

Schema description coverage is 0%, so the description must compensate. It does map both required parameters conceptually — 'vật liệu' to ten_vat_lieu and 'đối tượng' to ten_doi_tuong — but adds nothing about whether those names must match existing entities exactly or about naming conventions.

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 pair: assign ('gán') a material ('vật liệu') onto an object ('đối tượng'), and the mention of 'đã tạo' (already created) hints this consumes an existing material rather than making one. It is clear what the tool does, but it does not name or distinguish itself from siblings like tao_vat_lieu or sua_doi_tuong.

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?

'Đã tạo' (already created) weakly implies the material must exist beforehand, which is a prerequisite hint. Beyond that there is no when-to-use guidance, no statement of when not to use it, and no reference to any alternative tool, so 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?

No annotations are provided, so the description carries the full burden. It does disclose one non-obvious behavior — the empty-argument case returns the topic list — and implies a safe read operation. It says nothing about output format, permissions, or what 'business guide' content looks like, and an output schema exists to cover the return shape.

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, zero waste, with the primary instruction (read the guide first) front-loaded ahead of the discovery tip. Nothing extraneous.

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 an output schema present, return values need not be explained, and a single optional parameter keeps complexity low. However, with no annotations and no parameter description, the definition leaves an agent guessing about the kind of guide content and topic naming. Adequate but with visible 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 coverage is 0%: 'chu_de' has no description. The description partially compensates by implying that the argument selects a topic and that leaving it blank lists topics, which effectively documents the parameter's semantics. That is enough to reach a baseline 3, but no format or accepted-value detail is added.

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: read ('doc') the business/workflow guide ('huong dan nghiep vu') before performing a task. An agent can tell this is a documentation-lookup tool distinct from the drawing/modeling siblings. It stops short of explicitly differentiating itself from any sibling, but the purpose 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?

Gives clear context ('before doing a task') and a concrete usage rule: leave the argument blank to list available topics. This is a real when-to-use instruction with a discovery path. No exclusions or named alternatives, so it falls 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation of existing geometry but says nothing about reversibility, whether the wall is modified in place, permission requirements, or the response shape. For a destructive CAD edit this is a notable gap.

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?

Purpose is front-loaded in one sentence, followed by a compact parameter list with no filler. Only the omission of two required parameters keeps it from being fully efficient.

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 annotations, no output schema, and 5 parameters, the description should do more: two required parameters (rong, cao) are never explained and nothing is said about the result of the cut or how it affects the wall. Adequate for the core action but materially incomplete for a mutation 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 0%, so the description must compensate and it partially does: it explains ten_tuong (source object name), khoang_cach (offset from wall start to hole left edge), and be_cua (hole bottom height with concrete values, door=0, window=0.9). It omits the two other required parameters rong (width) and cao (height), leaving them undocumented anywhere.

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 (khoet) plus resource (lo cua/cua so) and constrains it to 'mot buc tuong da dung' (an already-built wall), which implicitly separates it from construction siblings like dung_tuong. An agent can identify the operation without opening the schema, though no sibling is named explicitly.

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

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

'tren mot buc tuong da dung' implies the prerequisite that a wall must already exist and that its name comes from dung_tuong results, which is real context. However there is no explicit when-to-use vs when-not guidance and no alternatives offered (e.g. sua_doi_tuong for editing existing geometry).

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

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

No annotations are provided, so the description carries the full burden. It discloses failure behavior (an error will explain how to enable the addon), which is useful. But it doesn't state what a successful response looks like or any timeout/retry characteristics.

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

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

Two short sentences, front-loaded with the core purpose followed by the ordering instruction. No wasted words; appropriate for a simple connectivity check.

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 connectivity check with no output schema, the description covers purpose, usage order, and failure mode. It could mention what success returns, but the essential information an agent needs is present.

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 0 parameters with 100% schema coverage, so the baseline is 4. The description correctly implies a parameterless invocation and adds no confusing parameter information.

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: 'Kiem tra' (check) whether the MCP server can connect to Blender. Its purpose as a connectivity/health check is clear and distinguishable from sibling tools like xem_canh or render_anh. It doesn't explicitly contrast with a sibling, so not 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?

Explicitly says 'Goi tool nay dau tien' (call this tool first), giving clear usage ordering guidance. It also tells the agent what happens on failure (error message will point to how to enable the addon). However it doesn't state when-not-to-use or name 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that the result is a displaced duplicate, but says nothing about whether the original remains, what permissions are needed, whether the operation is undoable, or how the new object is identified/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 compact sentence with the action front-loaded and the unit clarification appended; no filler. It is efficient, though it omits information the agent actually needs, which is under-specification rather than verbosity.

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 annotations, no output schema, three parameters at 0% schema coverage, and an unexplained 'ten_moi', the description is not complete enough for reliable invocation. It never states what the tool returns or how the duplicated object is named.

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 description only clarifies one of three parameters: 'lech' is a [dx, dy, dz] vector in meters. The required 'ten' (source object name) and especially the optional 'ten_moi' (new name) are never explained, leaving a meaningful gap for a parameter that implies copy-naming 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?

States a specific verb and resource ('nhan ban mot doi tuong' – duplicate an object) plus the transformation applied (offset by a vector). An agent can tell this is a copy-with-displacement operation, though it is not explicitly distinguished from siblings like sua_doi_tuong or xoa_doi_tuong.

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 editing an object directly, when not to use it, or what preconditions exist (object must exist, be selected, etc.). The only contextual information is the meaning of the offset argument, which is parameter semantics rather than 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?

With no annotations, the description carries the full burden. It discloses that the tool produces a viewport image to review and describes the intended self-evaluation workflow, which is genuinely useful behavioral context. It omits where the image is returned, its format, or how the size cap affects it.

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 the core action before the usage advice and evaluation criteria. Efficient with little waste, appropriate for a simple viewport-capture tool.

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

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

No output schema means the description must carry return-value context; it implies an image is produced but does not specify format or location. Combined with an undocumented parameter and no annotations, the definition is adequate but leaves meaningful gaps for an agent to call and interpret it correctly.

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

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

Schema description coverage is 0% for the single parameter kich_thuoc_toi_da (max size), and the description never references it. No meaning, units, or effect on output is added, so the description fails to compensate for the schema 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 (capture/screenshot) and resource (Blender viewport) for the purpose of inspecting the just-built result. However, with many visually-similar siblings like xem_canh, xem_doi_tuong, and render_anh, it does not explicitly differentiate itself from those alternatives, so an agent must infer the distinction.

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 usage context: call after every significant build step, then look at the image and self-evaluate for floating blocks, intersections, or wrong proportions. This is a concrete when-to-use instruction, though it offers no explicit when-not or named alternatives.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses a performance characteristic (slower than 'nhin') and the side effect of persisting a file when 'duong_dan' is supplied, but says nothing about what happens when 'duong_dan' is omitted, whether the chosen engine must be pre-configured, or what the operation returns.

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 clipped sentences with no wasted words; the core action is front-loaded and the file-saving hint is placed last. The elliptical phrasing is terse but each sentence contributes something.

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 two-parameter, zero-annotation, no-output-schema tool, the description covers the action, the sibling tradeoff, and one parameter. It stops short of covering the max-size parameter, engine configuration prerequisites, or what a render produces when no output path is given.

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 two parameters, so the description must compensate. It explains 'duong_dan' as the path that saves the rendered file, which adds real meaning, but 'kich_thuoc_toi_da' (max size, default 1600) is never mentioned, leaving half the 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?

States a specific verb+resource ('render anh' / render the image) and explicitly contrasts itself with the sibling 'nhin' (view), noting it is slower but produces better output. That differentiation lets an agent pick between rendering and viewing without opening either schema. It does not address other related siblings like 'cai_dat_render' or 'xuat_file'.

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

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

The comparison 'cham hon nhin nhung cho ra anh dep' implies a usage tradeoff (use when output quality matters, not when speed matters) and it says to pass 'duong_dan' to save the file. However, neither the when-not condition nor prerequisites such as configuring the engine via 'cai_dat_render' are stated explicitly.

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

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

No annotations are provided, so the description carries the full burden. It discloses one useful behavioral fact ('Goc tinh bang do' – angle in degrees) for the rotation parameter, but says nothing about reversibility, permissions, partial-update behavior when optional args are null, or what happens when 'ten' matches nothing. For an unannotated mutation tool this is a substantial gap.

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 one unit clarification. No filler or repetition; it is terse without being 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?

A five-parameter mutation tool with zero schema description coverage, no annotations, and no output schema. The description never explains whether unset optional fields leave values unchanged, what the target 'ten' must match, or what the call returns. Given the complexity signals, it is under-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 0%, so the cryptic Vietnamese property titles (ty_le, vi_tri, xoay_do, ten_moi) are the only structured guidance. The description helpfully maps them to concepts (position, rotation, scale, new name) and supplies the degrees unit for rotation, which the schema lacks. It still omits array formats/lengths for vi_tri, ty_le and xoay_do, so it only partially compensates.

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 ('Doi' = change) plus the resource (a doi tuong) and enumerates the four mutable attributes: position, rotation, scale, name. An agent can immediately tell this is a mutation tool for existing objects, though nothing in the text distinguishes it from siblings like nhan_ban or xoa_doi_tuong.

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 guidance, no prerequisites (e.g. must the object already exist or be selected?), and no mention of alternatives such as xoa_doi_tuong or nhan_ban. The agent must infer usage entirely from the name and schema.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether creating a camera replaces an existing one, whether it becomes the active render camera, whether it affects the current view, or whether the operation is reversible — all material for a scene-mutating tool with a 'dat_lam_chinh' (set as main) flag.

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 with the core action front-loaded and no filler. It is efficient, though the second sentence is spent on one parameter rather than on the gaps that matter more.

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

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

With five parameters, zero schema descriptions, no annotations and no output schema, the description is far too thin. An agent cannot determine what the required position array means, what the look-at target does, or what 'set as main' changes in the scene.

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 five parameters, but the description only explains one of them (tieu_cu, the focal length). Position ('vi_tri', the sole required param), look-at target ('nhin_vao'), name ('ten') and the set-as-main flag ('dat_lam_chinh') receive no explanation anywhere.

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 in Vietnamese: place a camera and aim it at a point. That is unambiguous about what the tool does, but it never distinguishes itself from nearby siblings such as 'nhin' (look) or 'render_anh' (render), which an agent must choose between.

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 offers practical guidance for choosing a value ('35 for wide perspective, 50 for a human-eye view'), which is genuinely useful when picking a lens. However, it says nothing about when to create a camera at all, what prerequisites exist, or how this differs from the sibling 'nhin'/'render_anh' workflow.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the SUN direction behavior but says nothing about whether the call mutates the scene, whether it is reversible, what the defaults produce, what units goc_do/cong_suat use, or what the tool returns.

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?

Only two short sentences, front-loaded with the creation verb and the valid type values, with no filler. The second clause is somewhat telegraphic and the line break breaks flow, but nothing is wasted.

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

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

For a 5-parameter creation tool with no annotations, no output schema and 0% schema description coverage, the definition is far too thin. An agent cannot determine units, coordinate conventions, default effects, or how to distinguish this tool from the environment-lighting sibling.

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 5 parameters, so the description must compensate. It partially covers two: 'kieu' (SUN, POINT, SPOT, AREA) and 'goc_do' for SUN, but leaves 'ten', 'vi_tri' and 'cong_suat' completely unexplained, including expected array formats and units.

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 ('tao nguon sang' = create a light source) and enumerates the supported light kinds, so the agent knows exactly what gets created. It does not, however, differentiate itself from the lighting-related sibling 'anh_sang_moi_truong' (environment lighting), which an agent must otherwise infer.

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 note that SUN is used as sunlight and that goc_do governs its direction gives implied usage for one mode, which helps the agent pick the right kind. There is no explicit when-to-use/when-not, no prerequisites, and no routing to or away from sibling tools such as anh_sang_moi_truong or tao_camera.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the valid 'loai' values and the 'mau' color format/range, but says nothing about what creation does (persistence, duplicate-name handling, idempotency) or any side effects — significant gaps for a creation tool.

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

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

Two sentences, purpose front-loaded, no filler. The type list is a slightly unwieldy run-on but every item earns its place as a valid input 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?

With no annotations, no output schema, 3 params and 0% schema coverage, the description covers the type enum and color format but leaves the required 'ten' semantics and the creation behavior unexplained. Adequate for calling the tool, incomplete for understanding its effects.

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

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

Schema description coverage is 0%, so the description must compensate. It does add real meaning: the ten valid 'loai' values and the 'mau' format '[r,g,b] trong khoang 0 den 1'. It says nothing about 'ten', though that is self-evident as the material name.

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 vật liệu xây dựng' = create construction material), which is unambiguous. It does not name or contrast with any sibling (e.g. gan_vat_lieu, which assigns rather than creates), but no sibling directly overlaps, so the purpose is still distinguishable.

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

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

There is no guidance on when to use this tool versus alternatives such as gan_vat_lieu, nor any prerequisites (e.g. must a project/model exist first). It only enumerates valid material types, which is value semantics rather than 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?

No annotations are provided, so the description carries the full burden, yet it reveals almost nothing behavioral: it does not say the result is truncated (gioi_han default 100), whether output is paginated, or what the listing is scoped to by default. For a no-annotation tool this is a significant gap.

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 lines with the core purpose front-loaded and no filler. It is efficient, though the fragmentary second line would read better as part of a single coherent 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?

With no annotations, no output schema, and 0% schema coverage, the description should do more: the default limit of 100 and the resulting truncation behavior are unmentioned, leaving the agent unable to predict what it will get back.

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 2 parameters. The description explains only chi_cua_addon (addon-created objects only) and says nothing about gioi_han, so half the parameters remain undocumented in both schema and description.

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

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

The description states a clear verb+resource: listing objects present in the Blender scene. However, it does not differentiate itself from siblings such as xem_doi_tuong (view object), so an agent cannot tell from the text alone which listing tool applies when.

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

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

There is no guidance on when to use this tool versus alternatives like xem_doi_tuong, nor any prerequisite or exclusion. The scoping note about chi_cua_addon is a filter explanation, not a when-to-use 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?

With no annotations, the description carries the full burden, and 'Xem' does communicate a non-mutating read. It also discloses the returned fields (position, size, material, structural diagram), which is real value since there is no output schema. However, it omits error behavior when the object is not found and any access/permission expectations.

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

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

One compact sentence, front-loaded with the verb and resource, followed by the concrete list of attributes. Nothing is wasted, though the single-line format leaves no room for the missing guidance.

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

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

For a one-parameter read tool with no output schema, the description covers what the tool returns, which is the main thing an agent needs. It is nonetheless incomplete on the meaning of the required 'ten' argument and on failure behavior.

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 single parameter 'ten' has 0% schema description coverage, so the description must compensate and it largely does not – it never explains that 'ten' is the object name used to identify the target. Only indirectly inferable from the phrase 'mot doi tuong'.

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 ('Xem chi tiet' – view details) plus the resource ('mot doi tuong' – an object) and enumerates the returned attributes (position, size, material, structural diagram). This clearly separates it from the mutating siblings sua_doi_tuong/xoa_doi_tuong, though it does not name an alternative explicitly.

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

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

Usage is only implied: the read-only nature and the presence of sua_doi_tuong/xoa_doi_tuong in the sibling set make 'inspect an object' the obvious use case, but the description never states when to prefer this over xem_canh or when-not to use it. Minimum viable, no explicit routing guidance.

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

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

No annotations are provided, so the description carries the full burden for a destructive operation. It says an object is removed but discloses nothing about irreversibility, undo behavior, failure when the name does not exist, or whether dependent geometry is affected.

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 that front-loads the action and resource with no filler. It is appropriately sized, though its brevity reflects under-specification rather than disciplined 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 destructive tool with no annotations, no output schema, and an undocumented required parameter, the definition is not sufficient. An agent cannot tell what happens on success or failure, or what safety constraints apply.

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 single parameter 'ten' has 0% schema description coverage, and the description never explains what 'ten' is (object name, handle, or ID) or its expected format. With one undocumented required parameter, the description fails to compensate for the schema 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?

The description states a specific verb and resource ('xoa mot doi tuong' = delete an object) with scope ('khoi canh' = from the scene), so the core action is unambiguous. It does not distinguish this from siblings such as xoa_toan_bo (delete everything) or sua_doi_tuong (edit object), 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?

There is no guidance on when to use this tool versus alternatives like xoa_toan_bo or sua_doi_tuong, and no stated prerequisites such as the target object needing to exist first. The agent must infer all routing on its own.

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

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

No annotations are provided, so the description carries the full burden. It does add real value for a destructive operation: it discloses the default limited scope and warns to consider carefully before expanding it. It stops short of stating irreversibility, whether deletion is reversible, or permission requirements.

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

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

Three short sentences, front-loaded with the core scope, then the parameter effect, then the caution. No filler, though the caution sentence could be merged with the parameter 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?

For a one-parameter destructive tool with no annotations and no output schema, the description covers scope, parameter effect, and a warning. Return value is not described, but that is minor for a delete operation and no output schema exists to carry 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 0% and the single parameter (chi_cua_addon) is documented only by its name. The description compensates fully: default = addon collection only, False = clean the whole scene. This gives the agent the exact effect of both boolean values.

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: deleting the objects this addon itself created. It scopes 'what gets deleted' clearly, which is genuinely more informative than the name xoa_toan_bo ('delete all') alone, though it never explicitly contrasts itself with the sibling xoa_doi_tuong.

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 explains the default scope (only the addon's own collection) and the condition under which broader deletion occurs (chi_cua_addon=False), plus a caution. However it never names an alternative tool or states when a user should prefer xoa_doi_tuong for targeted deletion, so routing 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses nothing about whether the export overwrites an existing file at duong_dan, what permissions or preconditions are needed, whether the model must already exist, or what the tool returns; for a disk-writing operation this is a significant gap.

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 action is front-loaded in the first sentence, the format list follows, and the format trade-off note is short and earns its place. It is efficient, though the trailing newline/whitespace and terse style leave it thinner than the tool's complexity warrants.

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 three parameters, no annotations, no output schema, and 0% schema coverage, the description should explain path format, the meaning of chi_cua_addon, and the effect of exporting. It covers only format choice, leaving an agent unable to call the tool correctly in edge cases.

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

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

Schema description coverage is 0% across three parameters, and the description only compensates for one of them (dinh_dang, whose allowed values glb/fbx/obj/stl it lists). duong_dan and chi_cua_addon remain completely undocumented in both the schema and the description, leaving the required path parameter and the addon-scoping flag 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?

States a specific verb and resource ('Xuat mo hinh ra file' = export the model to a file) and enumerates the supported formats (glb, fbx, obj, stl). It is clearly distinct from the modeling siblings, but it never explicitly names or contrasts an alternative, 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?

The description gives useful context for choosing a format value (glb for web/mobile viewing, fbx for moving to other software), which is implied usage guidance. However it says nothing about when to use this tool versus other output-oriented siblings such as render_anh, and there are 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.